myvtm/Framework/RVCComm/test/RVCCommTest.cpp

//
// Created by tmd67 on 2020/3/24.
//

//real environment: use rvccomm to connect installservice

#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "RVCComm.h"
#include <winpr/winsock.h>
#include <winpr/wtypes.h>
#include <memory>
#include <iostream>
#include <winpr/string.h>

#pragma pack(1)
typedef struct _DevInfoReq
{
    char TerminalNo[16];
}TerminalRegistReq;

typedef struct _DevInfoRcv
{
    char TerminalNo[16];
    char DeviceNo[16];
    char OutletNo[6];
    char Initializer[32];
    BYTE InitIP[4];
    BYTE CreateTime[4];
    char PadDeviceID[32];
    char MachineType[16];
    BYTE MachineVersion[4];
    char Sites[16];
    BYTE EnrolGPS[8];
    char EnrolAddr[512];
    BYTE AuthorizedTime[4];
    BYTE BusinessStructID[8];
    BYTE StructID[8];
    char Editor[32];
    BYTE EditTime[4];
    char State;
    char PublicKey[512];
    char FingerPrint[512];
}TerminalRegistRet;

#pragma pack()

class QueryTerminalInfo : public CSecureClientBase
{    //main function
public:
    QueryTerminalInfo()
    {
        WORD wVersionRequested;
        WSADATA wsaData;
        int err;
        wVersionRequested = MAKEWORD(1, 1);
        err = WSAStartup(wVersionRequested, &wsaData);
        if (err != 0)
            return;
    }
	virtual ~QueryTerminalInfo(){
        WSADATA wsaData;
        if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
        {
            WSACleanup();
            return;
        }
	}
    bool Connect(const char *pServerAddr, int nPort)
    {
        return  GetFunction()->Connect(pServerAddr, nPort, 3);
    }
    bool IsConnectionOK()
    {
        return GetFunction()->IsConnectionOK();
    }
    void CloseConnection(){
        if (GetFunction()->IsConnectionOK())
            GetFunction()->Close();
    }
    std::pair<bool, std::string> SendSayHelloReq(char *tempNo)
    {
        TerminalRegistReq terminalNo;
        memset(&terminalNo, 0, sizeof(TerminalRegistReq));
        sprintf_s(terminalNo.TerminalNo, strlen(tempNo) + 1, "%s", tempNo);

        CSmartPointer<IPackage> package = GetFunction()->CreateNewPackage("SayHello");
        package->AddStruct("TerminalRegistReq", false, false, (BYTE*)&terminalNo, sizeof(terminalNo));
        string strPackageID = GetFunction()->SendPackage(package);
        auto ret = GetFunction()->ReceivePackage(10000);
        return DealSayHelloRet(ret);
    }

    virtual void OnReceivePackage(CSmartPointer<IPackage>& pRecvPkg) {};
	
    TerminalRegistRet terminalPara;
	


private:

    virtual void OnClose(){
        cout << "connection closed" << endl;
    }
    virtual void OnError(DWORD dwSysCode, DWORD dwUserCode, const char *pErrMsg)
    {
        cout << "OnError SysCode= " << dwSysCode << ", UserCode = " << dwUserCode << ", ErrMsg = " << pErrMsg << endl;
    }
    virtual void OnAuthPass(){
        cout << "OnAuthPass" << endl;
    }
    std::pair<bool, std::string> DealSayHelloRet(const CSmartPointer<IPackage> &pRecvPkg){
        DWORD dwSysCode, dwUserCode;
        string strErrMsg;

        if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
            return std::make_pair(false, "error in package: " + strErrMsg);
        else
        {
            int nLen = pRecvPkg->GetStructLen("TerminalRegistRet");
            if (nLen <= 0)
                return std::make_pair(false, "not find struct [TerminalRegistRet] in package");
            else
            {
                std::unique_ptr<BYTE[]> pBuf(new BYTE[nLen]);
                memset(pBuf.get(), 0, nLen);

                int nArrayNum = 0;
                if (!pRecvPkg->GetStructData("TerminalRegistRet", pBuf.get(), &nLen, &nArrayNum))
                {
                    delete[] pBuf.get();
                    return std::make_pair(false, "get struct [TerminalRegistRet] data fail");
                }
                else
                {
                    TerminalRegistRet *pReq = (TerminalRegistRet*)pBuf.get();
                    memcpy(&terminalPara, pReq, sizeof(TerminalRegistRet));
                }
            }
        }
        return std::make_pair(true, "");
    }
};

#define TEST_IP "99.12.98.156"
#define TEST_PORT   1050
#define TEST_TERMINAL   "7715015056"
#define TEST_MachineType "RVC.Stand2S"
#define TEST_EnrolAddr  "广东省深圳市南山区科技园北区科技中一路3号"

TEST(RvccommTest, InstallServiceTest)
{
    std::shared_ptr<QueryTerminalInfo> tmpConnect(new QueryTerminalInfo(), [](QueryTerminalInfo *p){
        p->CloseConnection();
    });
    ASSERT_TRUE(tmpConnect->Connect(TEST_IP, TEST_PORT));
    ASSERT_TRUE(tmpConnect->IsConnectionOK());

    auto ret = tmpConnect->SendSayHelloReq(TEST_TERMINAL);
    ASSERT_TRUE(ret.first == true);
    ASSERT_TRUE(tmpConnect->terminalPara.TerminalNo == std::string(TEST_TERMINAL));
    ASSERT_TRUE(tmpConnect->terminalPara.MachineType == std::string(TEST_MachineType));
    ASSERT_TRUE(tmpConnect->terminalPara.EnrolAddr == std::string(TEST_EnrolAddr));
}