Esempio n. 1
0
 public void Then_Payload_Was_Sent()
 {
     MockSocketClient
     .Received()
     .Send(Arg.Is <byte[]>(payload => payload.SequenceEqual(_payload)));
     MockSocketClient
     .Received(1)
     .Send(Arg.Any <byte[]>());
 }
 public void Then_Communication_Was_In_Order()
 {
     Received.InOrder(
         () =>
     {
         MockSocketClient.Connect();
         MockSocketClient.Send(Arg.Any <byte[]>());
         MockSocketClient.Recieve();
         MockSocketClient.Close();
     }
         );
 }
Esempio n. 3
0
        protected override void When()
        {
            Operation = new OperationDto
            {
                Device = 1, Operation = 1, Params = new[] { 1 }
            };
            Payload = new byte[] { 1, 1, 1, 1 };
            MockSocketClient
            .Recieve()
            .Returns(_operationResponseParams);

            _result = SUT.SendOperation(Operation);
        }
Esempio n. 4
0
        protected override void When()
        {
            Operation = new OperationDto
            {
                Device = 1, Operation = 1, Params = new[] { 1 }
            };
            Payload = new byte[] { 1, 1, 1, 1 };
            MockSocketClient
            .Recieve()
            .Returns(_operationResponseParams);

            Assert.Throws <ArgumentException>(() => SUT.SendOperation(Operation));
        }
        protected override void When()
        {
            Operation = new OperationDto
            {
                Operation = 115,
                Device    = 121,
                Params    = new[] { 65535 }
            };
            MockSocketClient
            .When(x => x.Connect())
            .Do(x => throw _socketException);

            Assert.Throws <SocketException>(() => SUT.SendOperation(Operation));
        }
Esempio n. 6
0
        protected override void When()
        {
            Operation = new OperationDto
            {
                Operation = 115,
                Device    = 121,
                Params    = new[] { 65535 }
            };

            MockSocketClient
            .Recieve()
            .Throws(_socketException);

            Assert.Throws <SocketException>(() => SUT.SendOperation(Operation));
        }
Esempio n. 7
0
        protected override void When()
        {
            Payload   = new byte[] { 115, 121, 2, 255, 255 };
            Operation = new OperationDto
            {
                Operation = 115,
                Device    = 121,
                Params    = new[] { 65535 }
            };
            _operationResponse = new OperationResponseDto
            {
                Status  = 115,
                Returns = 65535
            };

            MockSocketClient
            .Recieve()
            .Returns(new byte[] { 115, 2, 255, 255, 0, 0, 0, 0 });

            _result = SUT.SendOperation(Operation);
        }
Esempio n. 8
0
 public void Then_Data_Was_Attempted_To_Be_Received()
 {
     MockSocketClient
     .Received(1)
     .Recieve();
 }
 public void Then_Data_Was_Not_Received()
 {
     MockSocketClient
     .DidNotReceive()
     .Recieve();
 }
 public void Then_Connection_Was_Attempted_To_Be_Opened()
 {
     MockSocketClient
     .Received(1)
     .Connect();
 }
 public void Then_Connection_Was_Closed()
 {
     MockSocketClient
     .Received(1)
     .Close();
 }
 public void Then_Payload_Was_Not_Sent()
 {
     MockSocketClient
     .DidNotReceive()
     .Send(Arg.Any <byte[]>());
 }
 public void Then_Data_Was_Received()
 {
     MockSocketClient
     .Received(1)
     .Recieve();
 }