public async Task FakeServer_ExpectGetWithRequestHeadersSpecified_WhenRequestHeadersProvided_ResponseMatchesExpection()
        {
            const string expectedResult = "Some String Data";

            var port = Ports.GetFreeTcpPort();

            var baseAddress = "http://localhost:" + port;

            const string url = "/some-url";

            using (var fakeServer = new FakeServer(port))
            {
                var expectedRequestHeaders = new WebHeaderCollection
                {
                    {"X-Dummy1", "dummy1val"},
                    {"X-Dummy2", "dummy2val"},
                    {"X-Dummy3", "dummy3val"}
                };

                fakeServer.Expect.Get(url, expectedRequestHeaders).Returns(expectedResult);
                fakeServer.Start();

                var client = new HttpClient { BaseAddress = new Uri(baseAddress) };

                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.TryAddWithoutValidation("X-Dummy1", "dummy1val");
                client.DefaultRequestHeaders.TryAddWithoutValidation("X-Dummy2", "dummy2val");
                client.DefaultRequestHeaders.TryAddWithoutValidation("X-Dummy3", "dummy3val");

                var result = await client.GetAsync(url);

                result.StatusCode.Should().Be(HttpStatusCode.OK);
                result.Content.ReadAsStringAsync().Result.Should().Be(expectedResult);
            }
        }
        public void FakeServer_CapturesAllRequests()
        {
            using (var fakeServer = new FakeServer())
            {
                fakeServer.Start();
                var baseAddress = fakeServer.BaseUri;

                Action<Action, int> repeat = (a, times) =>
                {
                    for (var i = 0; i < times; i++)
                        a();
                };

                var url1 = "/request1";
                var url2 = "/request2";
                var url3 = "/request3";
                var url4 = "/request4";

                var httpClient = new HttpClient();
                httpClient.DeleteAsync(new Uri(baseAddress + url1)).Wait();
                repeat(() => httpClient.GetAsync(new Uri(baseAddress + url2)).Wait(), 2);
                repeat(() => httpClient.PostAsync(new Uri(baseAddress + url3), new StringContent(url3)).Wait(), 3);
                repeat(() => httpClient.PutAsync(new Uri(baseAddress + url4), new StringContent(url4)).Wait(), 4);

                fakeServer.CapturedRequests.Count(x => x.Method == Http.Delete && x.Url == url1).Should().Be(1);
                fakeServer.CapturedRequests.Count(x => x.Method == Http.Get && x.Url == url2).Should().Be(2);
                fakeServer.CapturedRequests.Count(x => x.Method == Http.Post && x.Url == url3 && x.Body == url3).Should().Be(3);
                fakeServer.CapturedRequests.Count(x => x.Method == Http.Put && x.Url == url4 && x.Body == url4).Should().Be(4);
            }
        }
        public IBucket GetBucketForKey(string key)
        {
            var config = new ClientConfiguration();
            var fakeServer = new FakeServer(_connectionPool, null, null, _endPoint,
                new FakeIOService(_endPoint, _connectionPool, false));

            var mockVBucket = new Mock<IVBucket>();
            mockVBucket.Setup(x => x.LocatePrimary()).Returns(fakeServer);

            var mockKeyMapper = new Mock<IKeyMapper>();
            mockKeyMapper.Setup(x => x.MapKey(key, It.IsAny<uint>())).Returns(mockVBucket.Object);

            var mockConfigInfo = new Mock<IConfigInfo>();
            mockConfigInfo.Setup(x => x.GetKeyMapper()).Returns(mockKeyMapper.Object);
            mockConfigInfo.Setup(x => x.BucketConfig).Returns(_bucketConfig);
            mockConfigInfo.Setup(x => x.GetServer()).Returns(fakeServer);
            mockConfigInfo.Setup(x => x.IsDataCapable).Returns(true);
            mockConfigInfo.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());

            var mockController = new Mock<IClusterController>();
            mockController.Setup(x => x.Configuration).Returns(config);
            mockController.Setup(x => x.CreateBucket("default", "", null))
                .Returns(new CouchbaseBucket(mockController.Object, "default", _converter, _transcoder, null));

            var cluster = new Cluster(config, mockController.Object);
            var bucket = cluster.OpenBucket("default", "");

            //simulate a config event
            ((IConfigObserver)bucket).NotifyConfigChanged(mockConfigInfo.Object);

            return bucket;
        }
        public IBucket GetBucketForKey(string key)
        {
            var config = new ClientConfiguration();
            var fakeServer = new FakeServer(_connectionPool, null, null, _endPoint,
                new FakeIOStrategy(_endPoint, _connectionPool, false));

            var mappedNode = new Mock<IMappedNode>();
            mappedNode.Setup(x => x.LocatePrimary()).Returns(fakeServer);

            var mockKeyMapper = new Mock<IKeyMapper>();
            mockKeyMapper.Setup(x => x.MapKey(key)).Returns(mappedNode.Object);

            var mockConfigInfo = new Mock<IConfigInfo>();
            mockConfigInfo.Setup(x => x.GetKeyMapper()).Returns(mockKeyMapper.Object);
            mockConfigInfo.Setup(x => x.BucketConfig).Returns(_bucketConfig);
            mockConfigInfo.Setup(x => x.GetServer()).Returns(fakeServer);

            var mockController = new Mock<IClusterController>();
            mockController.Setup(x => x.Configuration).Returns(config);
            mockController.Setup(x => x.CreateBucket("memcached", ""))
                .Returns(new MemcachedBucket(mockController.Object, "memcached", _converter, _transcoder));

            var cluster = new Cluster(config, mockController.Object);
            var bucket = cluster.OpenBucket("memcached", "");

            //simulate a config event
            ((IConfigObserver) bucket).NotifyConfigChanged(mockConfigInfo.Object);

            return bucket;
        }
Exemple #5
0
 public void EmptyStringExpr()
 {
     // Setup
     string input = "\'\' LIKE Map";
     var filter = new Filter<FakeServer>(input);
     var s1 = new FakeServer() { Map = "" };
     var s2 = new FakeServer() { Map = "ą" };
     Assert.AreEqual(true, filter.Function(s1));
     Assert.AreEqual(false, filter.Function(s2));
 }
Exemple #6
0
 public void InvalidPropertyExpr()
 {
     // Setup
     string input = "\'tr-_ala%lala\' LIKE Kabanos";
     var filter = new Filter<FakeServer>(input);
     var s1 = new FakeServer() { Map = "" };
     var s2 = new FakeServer() { Map = "ą" };
     Assert.AreEqual(true, filter.Function(s1));
     Assert.AreEqual(true, filter.Function(s2));
 }
Exemple #7
0
 public void InvalidPropertyGroupExpr()
 {
     // Setup
     string input = "(\'tr-_ala%lala\' LIKE Kabanos) OR (Map Like \'a\')";
     var filter = new Filter<FakeServer>(input);
     var s1 = new FakeServer() { Map = "" };
     var s2 = new FakeServer() { Map = "ą" };
     var s3 = new FakeServer() { Map = "a" };
     Assert.AreEqual(false, filter.Function(s1));
     Assert.AreEqual(false, filter.Function(s2));
     Assert.AreEqual(true, filter.Function(s3));
 }
Exemple #8
0
 public void StringExprComplexPattern()
 {
     // Setup
     string input = @"(Map LIKE '\%\^%\_')";
     var filter = new Filter<FakeServer>(input);
     var s1 = new FakeServer() { Map = "kabanosnos" };
     var s2 = new FakeServer() { Map = @"%^_" };
     var s3 = new FakeServer() { Map = "a" };
     Assert.AreEqual(false, filter.Function(s1));
     Assert.AreEqual(true, filter.Function(s2));
     Assert.AreEqual(false, filter.Function(s3));
 }
Exemple #9
0
        public void FakeServer_RequestingAUriThatHasNotBeenModified_ResponseMatchesExpectation()
        {
            const string expectedResult = "Some String Data";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get("/123").Returns(expectedResult);
                fakeServer.Start();

                var result = new WebClient().DownloadString(new Uri("http://www.bing.com/123"));

                result.Should().Be(expectedResult);
            }
        }
Exemple #10
0
        public void Get_Site_Informations_Test()
        {
            using (var fakeServer = new FakeServer(BASE_PORT))
            {
                fakeServer.Expect.Post("/enterprise/control/agent.php", "").Returns(System.Net.HttpStatusCode.OK, GET_SITE_INFORMATIONS_RESULT_XML);
                fakeServer.Start();

                var result = client.GetSite("domain.com");

                Assert.AreEqual(result.site.results.Length, 1);
                Assert.AreEqual(result.site.results[0].status, "ok");
                Assert.AreEqual(result.site.results[0].data.getInfo.Name, "sub.ppu12-5.demo.pp.plesk.ru");
            }
        }
Exemple #11
0
        public void NoLimit()
        {
            var query = new Query {
                Offset = 5
            };
            var server   = new FakeServer(11);
            var streamer = new QueryStreamer(new RunQueryRequest {
                Query = query
            }, server.CreateApiCall(), null);

            AssertEntities(streamer, 5, 15);
            AssertLimits(server, null, null);
            AssertOffsets(server, 5, 0);
        }
        public async Task RecaptchaWithValidCredentials_WithTooManyFailedLogins_ShouldPass()
        {
            const int NumberOfAllowedLoginFailures = 1;

            using (var fakeRecaptchaServer = new FakeServer())
            {
                fakeRecaptchaServer.Start();
                fakeRecaptchaServer.Expect.Get("/?secret=private_key&response=correct_response")
                .Returns(HttpStatusCode.OK, JsonConvert.SerializeObject(new RecaptchaVerificationResponse
                {
                    Succeeded = true
                }));

                var ipAddress = "192.168.1.101";
                var username  = "******";

                var identityServerBuilder = new IdentityServerWithRecaptcha()
                                            .WithProtectedGrantType("password")
                                            .WithPrivateKey("private_key")
                                            .WithVerificationUri(fakeRecaptchaServer.BaseUri)
                                            .WithNumberOfAllowedLoginFailuresPerIpAddress(NumberOfAllowedLoginFailures)
                                            .WithFailuresForIpAddress(ipAddress, NumberOfAllowedLoginFailures + 1)
                                            .WithChallengeAsBadRequest()
                                            .WithNumberOfAllowedLoginFailuresPerIpAddress(NumberOfAllowedLoginFailures);

                using (var server = identityServerBuilder.Build())
                {
                    var response = await server.CreateNativeLoginRequest()
                                   .WithUsername(username)
                                   .WithPassword("Passw0rd")
                                   .WithGrantType("password")
                                   .WithHttpHeaderRecaptchaResponseRaw("correct_response")
                                   .Build()
                                   .PostAsync();

                    response.StatusCode.Should().NotBe(HttpStatusCode.BadRequest);

                    identityServerBuilder.RecaptchaMonitor.HasCompletedChallenge.Should().BeTrue();
                    identityServerBuilder.RecaptchaMonitor.ChallengeCompletedInvokeCount.Should().Be(1);
                    identityServerBuilder.RecaptchaMonitor.ResponseContext.State.Should().Be(RecaptchaState.ChallengeSucceeded);
                    identityServerBuilder.RecaptchaMonitor.UserContext.ShouldBeEquivalentTo(new RecaptchaUserContext
                    {
                        Username  = username,
                        IpAddress = ipAddress,
                        Device    = new RecaptchaUserDevice()
                    });
                }
            }
        }
        public async Task FakeServer_ExpectGetReturnsString_ResponseMatchesExpectation()
        {
            const string expectedResult = "Some String Data";

            const string path = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path).Returns(expectedResult);
                fakeServer.Start();

                var result = await fakeServer.Client.GetStringAsync(path);
                result.Should().Be(expectedResult);
            }
        }
Exemple #14
0
        public void SetupFakeServer()
        {
            var sqliteDB = Create.TemporarySQLiteDB();

            sqliteDB.RegisterDataObject(typeof(DBCraftedItem));
            sqliteDB.RegisterDataObject(typeof(DBCraftedXItem));
            sqliteDB.RegisterDataObject(typeof(ItemTemplate));

            var fakeServer = new FakeServer();

            fakeServer.SetDatabase(sqliteDB);
            GameServer.LoadTestDouble(fakeServer);

            AddOneCompleteRecipeToDatabase();
        }
        public async Task FakeServer_ExpectGetWithMismatchingPath_Returns404()
        {
            const string expectedResult = "Some String Data";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get("/some-jibberish-path").Returns(expectedResult);

                fakeServer.Start();

                var resp = await fakeServer.Client.GetAsync("/home");

                resp.StatusCode.Should().Be(HttpStatusCode.NotFound);
            }
        }
Exemple #16
0
        public void FakeServer_ExpectGetWithMismatchingPath_Returns404()
        {
            const string expectedResult = "Some String Data";
            const string baseAddress    = "http://localhost:12354";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get("/some-jibberish-url").Returns(expectedResult);

                fakeServer.Start();

                var ex = Assert.Throws <WebException>(() => new WebClient().DownloadString(new Uri(baseAddress + "/home")));

                ((HttpWebResponse)ex.Response).StatusCode.Should().Be(HttpStatusCode.NotFound);
            }
        }
Exemple #17
0
 public void SimpleStringExpr()
 {
     // Setup
     string input = "\'%%ho sama\' LIKE Map";
     var filter = new Filter<FakeServer>(input);
     // Go
     var s1 = new FakeServer(){ Map = "ho sama" };
     var s2 = new FakeServer() { Map = "asdho sama" };
     var s3 = new FakeServer() { Map = "asdHo samA" };
     var s4 = new FakeServer() { Map = "Ho samĄ" };
      
     Assert.AreEqual(true, filter.Function(s1));
     Assert.AreEqual(true, filter.Function(s2));
     Assert.AreEqual(true, filter.Function(s3));
     Assert.AreEqual(false, filter.Function(s4));
 }
Exemple #18
0
        public void Add_WebSpace_Test()
        {
            using (var fakeServer = new FakeServer(BASE_PORT))
            {
                fakeServer.Expect.Post("/enterprise/control/agent.php", "").Returns(System.Net.HttpStatusCode.OK, WEBSPACE_RESULT);
                fakeServer.Start();

                var result = client.CreateWebSpace("domain.com", "192.168.0.1", "ftplogin", "password", "username", "password");

                Debug.WriteLine(result.ErrorText);

                Assert.AreEqual(result.status, "ok");
                Assert.AreEqual(result.Id, "4");
                Assert.AreEqual(result.guid, "5ff343c1-a40b-4305-8986-2f27c240db7e");
            }
        }
Exemple #19
0
        public void Add_Site_Test()
        {
            using (var fakeServer = new FakeServer(BASE_PORT))
            {
                fakeServer.Expect.Post("/enterprise/control/agent.php", "").Returns(System.Net.HttpStatusCode.OK, PleskClientTest.ADD_SITE_RESULT);
                fakeServer.Start();

                var result = client.CreateSite(1, "domain.com", null);

                Debug.WriteLine(result.ErrorText);

                Assert.AreEqual(result.status, "ok");
                Assert.AreEqual(result.Id, "57");
                Assert.AreEqual(result.guid, "ed5de3a1-2d73-4dfa-9cee-4609afaccf6a");
            }
        }
Exemple #20
0
        public void LimitAndOffset()
        {
            var query = new Query
            {
                Limit  = 7,
                Offset = 5
            };
            var server   = new FakeServer(4);
            var streamer = new QueryStreamer(new RunQueryRequest {
                Query = query
            }, server.CreateApiCall(), null);

            AssertEntities(streamer, 5, 7);
            AssertLimits(server, 7, 7, 4);
            AssertOffsets(server, 5, 1, 0);
        }
        public async Task FakeServer_ExpectPutWithObjectBodyReturns201_Returns201()
        {
            var expectedResult = new { RestaurantId = 1234 };

            const string path = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Put(path, string.Empty).Returns(HttpStatusCode.Created, expectedResult);
                fakeServer.Start();

                var result = await fakeServer.Client.PutAsync(path, new StringContent(string.Empty));

                result.StatusCode.Should().Be(HttpStatusCode.Created);
            }
        }
        public async Task FakeServer_ExpectPutWithNoBodyReturns2011_Returns201()
        {
            const string expectedResult = "Some String Data";

            const string path = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Put(path, string.Empty).Returns(expectedResult).WithHttpStatus(HttpStatusCode.Created);
                fakeServer.Start();

                var result = await fakeServer.Client.PutAsync(path, new StringContent(string.Empty));

                result.StatusCode.Should().Be(HttpStatusCode.Created);
            }
        }
        public async Task FakeServer_ExpectGetWithMismatchingMethod_Returns404()
        {
            const string expectedResult = "Some String Data";
            const string path           = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path).Returns(expectedResult);

                fakeServer.Start();

                var resp = await fakeServer.Client.PostAsync(path, new StringContent(string.Empty));

                resp.StatusCode.Should().Be(HttpStatusCode.NotFound);
            }
        }
        public async Task FakeServer_ExpectGetWithoutSlashAtTheStartOfUrl_ResponseMatchesExpectation()
        {
            const string expectedResult = "Some String Data";

            const string path = "some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path).Returns(expectedResult);
                fakeServer.Start();

                var result = await fakeServer.Client.GetStringAsync(path);

                result.Should().Be(expectedResult);
            }
        }
Exemple #25
0
 void BindView()
 {
     StartBtn = transform.Find("Button").GetComponent <Button>();
     StartBtn.onClick.AddListener(delegate()
     {
         if (NetManager.USE_FAKE_SERVER)
         {
             FakeServer.GetInstance().StartGame();
         }
         else
         {
             GameMain.GetInstance().netManager.TestConnect();
             GameMain.GetInstance().netManager.SendLoginReq();
         }
     });
 }
Exemple #26
0
        public async Task FakeServer_IgnoredParameterWithoutSlashAtTheStartOfUrlInRequest_Returns200()
        {
            var expectedResult = new { ResourceId = 1234 };

            const string fakepath   = "/some-resource/{ignore}/some-resource?date={ignore}&type={ignore}";
            const string actualpath = "some-resource/1234/some-resource?date=2015-02-06T09:52:10&type=1";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get(fakepath).Returns(HttpStatusCode.Accepted, expectedResult);
                fakeServer.Start();

                var result = await fakeServer.Client.GetAsync(actualpath);

                result.StatusCode.Should().Be(HttpStatusCode.Accepted);
            }
        }
Exemple #27
0
        public async Task FakeServer_IgnoredParameterInRestfulpath_Returns200()
        {
            var expectedResult = new { ResourceId = 1234 };

            const string fakepath   = "/some-resource/{ignore}/some-method";
            const string actualpath = "/some-resource/1234/some-method";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(fakepath).Returns(HttpStatusCode.Accepted, expectedResult);
                fakeServer.Start();

                var result = await fakeServer.Client.GetAsync(actualpath);

                result.StatusCode.Should().Be(HttpStatusCode.Accepted);
            }
        }
        public void FakeServer_ExpectGetReturnsString_ResponseMatchesExpectation()
        {
            const string expectedResult = "Some String Data";

            const string url = "/some-url";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(url).Returns(expectedResult);
                fakeServer.Start();

                var baseAddress = fakeServer.BaseUri;
                var result = new WebClient().DownloadString(new Uri(baseAddress + url));

                result.Should().Be(expectedResult);
            }
        }
        public async Task FakeServer_ExpectGetWithResponseHeadersSpecified_ResponseMatchesExpectionAndHasHeaders()
        {
            const string expectedResult = "Some String Data";

            const string path = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path).Returns(expectedResult, new WebHeaderCollection { { "foo", "bar" } });
                fakeServer.Start();

                var result = await fakeServer.Client.GetAsync(path);

                result.Content.ReadAsStringAsync().Result.Should().Be(expectedResult);
                result.Headers.Should().ContainSingle(x => x.Key == "foo");
            }
        }
        public async Task FakeServer_ExpectPostWithBodyAndPostWithNullBody_ResponseIsNotFound()
        {
            const string expectedResult = "Some String Data";

            const string path = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Post(path, "jiberish").Returns(expectedResult);

                fakeServer.Start();

                var resp = await fakeServer.Client.PostAsync(path, null);

                resp.StatusCode.Should().Be(HttpStatusCode.NotFound);
            }
        }
Exemple #31
0
        public async Task FakeServer_ExpectGetToAnEndpointWithAFiveSecondResponseTime_ResponseTimeIsGreaterThanFiveSeconds()
        {
            var expectedResult       = new { ResourceId = 1234 };
            var expectedResponseTime = TimeSpan.FromSeconds(1);

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.ResponseTime = expectedResponseTime;
                fakeServer.Expect.Get("/some-path").Returns(expectedResult).RespondsIn(TimeSpan.FromSeconds(5)).WithHttpStatus(HttpStatusCode.OK);
                fakeServer.Start();

                // Do not use stopwatch:
                var elapsedTime = await CallFakeServerWithAccurateUtcTimer(fakeServer);

                elapsedTime.Should().BeGreaterOrEqualTo(expectedResponseTime);
            }
        }
        public async Task TestNoAckFlow()
        {
            const string data = "The cuiqk brwon fox jumps over the zaly god.";

            var        server        = new FakeServer(SimulationMode.Success);
            var        connection    = new Connection(server.EndPoint, Connection.DefaultSocketFactory, BPool, RPool, 16, 16);
            const int  correlationId = 379821;
            const byte ack           = 1;
            var        buffer        = new ReusableMemoryStream(null);

            BigEndianConverter.Write(buffer, 4 + 4 + 1 + data.Length - 4);
            BigEndianConverter.Write(buffer, correlationId);
            buffer.WriteByte(ack);
            var s = Encoding.UTF8.GetBytes(data);

            buffer.Write(s, 0, s.Length);

            var bdata = buffer.ToArray();

            var p = new TaskCompletionSource <Response>();

            connection.Response +=
                (con, cor, b) => p.SetResult(new Response {
                Connection = con, CorrelationId = cor, Data = b
            });

            await connection.ConnectAsync();

            buffer.Position = 8;
            buffer.WriteByte(0);
            await connection.SendAsync(correlationId, buffer, false);

            buffer = new ReusableMemoryStream(null);
            buffer.Write(bdata, 0, bdata.Length);
            buffer.Position = 8;
            buffer.WriteByte(1);
            await connection.SendAsync(correlationId, buffer, true);

            var r = await p.Task;

            server.Stop();

            Assert.AreSame(connection, r.Connection);
            Assert.AreEqual(correlationId, r.CorrelationId);
            Assert.AreEqual(data, Encoding.UTF8.GetString(r.Data.ToArray()));
        }
        public async Task FakeServer_ExpectGetWithResponseHeadersSpecifiedFluently_ResponseMatchesExpectionAndHasHeaders()
        {
            const string expectedResult = "Some String Data";

            const string path = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path).Returns(expectedResult).WithHeader("Content-Language", "es").WithHeader("Some-Header", "Header-McHeaderFace");
                fakeServer.Start();

                var result = await fakeServer.Client.GetAsync(path);

                result.Content.ReadAsStringAsync().Result.Should().Be(expectedResult);
                result.Headers.Should().ContainSingle(x => x.Key == "Some-Header");
            }
        }
        public void FakeServer_ExpectDeleteReturnsString_ResponseMatchesExpectation()
        {
            const string expectedResult = "Some String Data";
            const string baseAddress = "http://localhost:12354";

            const string url = "/some-url";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Delete(url).Returns(expectedResult);
                fakeServer.Start();

                var result = new WebClient().UploadString(new Uri(baseAddress + url), "DELETE", string.Empty);

                result.Should().Be(expectedResult);
            }
        }
Exemple #35
0
        public void FakeServer_ExpectDeleteReturnsString_ResponseMatchesExpectation()
        {
            const string expectedResult = "Some String Data";
            const string baseAddress    = "http://localhost:12354";

            const string url = "/some-url";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Delete(url).Returns(expectedResult);
                fakeServer.Start();

                var result = new WebClient().UploadString(new Uri(baseAddress + url), "DELETE", string.Empty);

                result.Should().Be(expectedResult);
            }
        }
        public async Task FakeServer_ExpectGetWithQueryParametersReturnsString_ResponseMatchesExpectation()
        {
            const string expectedResult = "Some String Data";

            const string path = "/some-path?id=1234";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path).Returns(expectedResult);

                fakeServer.Start();

                var result = await fakeServer.Client.GetStringAsync(path);

                result.Should().Be(expectedResult);
            }
        }
Exemple #37
0
        public async Task FakeServer_ShouldExecuteResponseExpectationCallback_ReturnExpectedData()
        {
            const string expectedResult = "Some String Data";

            const string path = "/some-path?id=1234";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path).Callback(() => new HttpResponseExpectation(HttpStatusCode.OK, expectedResult));

                fakeServer.Start();

                var result = await fakeServer.Client.GetStringAsync(path);

                result.Should().Be(expectedResult);
            }
        }
Exemple #38
0
        public async Task TelemetryWorksWithConcurrentRequests()
        {
            this.MockHttpClientFixture.Reset();
            var fakeServer = FakeServer.ForMockHandler(this.MockHttpClientFixture.MockHandler);

            fakeServer.Delay = TimeSpan.FromMilliseconds(20);

            var service = new BalanceService(this.StripeClient);

            // the first 2 requests will not contain telemetry
            await Task.WhenAll(service.GetAsync(), service.GetAsync());

            // the following 2 requests will contain telemetry
            await Task.WhenAll(service.GetAsync(), service.GetAsync());

            this.MockHttpClientFixture.MockHandler.Protected()
            .Verify(
                "SendAsync",
                Times.Exactly(2),
                ItExpr.Is <HttpRequestMessage>(m =>
                                               !m.Headers.Contains("X-Stripe-Client-Telemetry")),
                ItExpr.IsAny <CancellationToken>());

            this.MockHttpClientFixture.MockHandler.Protected()
            .Verify(
                "SendAsync",
                Times.Once(),
                ItExpr.Is <HttpRequestMessage>(m =>
                                               TelemetryHeaderMatcher(
                                                   m.Headers,
                                                   (s) => s == "req_1",
                                                   (d) => d >= 15)),
                ItExpr.IsAny <CancellationToken>());

            this.MockHttpClientFixture.MockHandler.Protected()
            .Verify(
                "SendAsync",
                Times.Once(),
                ItExpr.Is <HttpRequestMessage>(m =>
                                               TelemetryHeaderMatcher(
                                                   m.Headers,
                                                   (s) => s == "req_2",
                                                   (d) => d >= 15)),
                ItExpr.IsAny <CancellationToken>());
        }
Exemple #39
0
        public async Task FakeServer_ExpectPutWithObjectBodyReturns201_Returns201()
        {
            var          expectedResult = new { RestaurantId = 1234 };
            const string baseAddress    = "http://localhost:12354";

            const string url = "/some-url";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Put(url, string.Empty).Returns(HttpStatusCode.Created, expectedResult);
                fakeServer.Start();

                var uri    = new Uri(baseAddress + url);
                var result = await new HttpClient().PutAsync(uri, new StringContent(String.Empty));

                result.StatusCode.Should().Be(HttpStatusCode.Created);
            }
        }
Exemple #40
0
        public void FakeServer_ExpectGetWithMismatchingMethod_Returns404()
        {
            const string expectedResult = "Some String Data";
            const string baseAddress    = "http://localhost:12354";
            const string path           = "/some-url";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get(path).Returns(expectedResult);

                fakeServer.Start();

                var uri = new Uri(baseAddress + path);
                var ex  = Assert.Throws <WebException>(() => new WebClient().UploadString(uri, string.Empty));

                ((HttpWebResponse)ex.Response).StatusCode.Should().Be(HttpStatusCode.NotFound);
            }
        }
        public async Task FakeServer_ExpectGetReturnsObject_ResponseMatchesExpectation()
        {
            var expectedResult = new { RestaurantId = 1234 };

            const string path = "/restaurant/1234";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path).Returns(expectedResult);

                fakeServer.Start();

                var resp = await fakeServer.Client.GetStringAsync(path);
                var result = JsonConvert.DeserializeObject<dynamic>(resp);

                Assert.Equal(expectedResult.RestaurantId, (int)result.RestaurantId);
            }
        }
        public async Task FakeServer_ExpectGetReturnsFileContent_ResponseMatchesExpectation()
        {
            const string path = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path)
                    .ReturnsFromFile(@"TestData\TestResponse.json");

                fakeServer.Start();

                var result = await fakeServer.Client.GetStringAsync(path);

                dynamic deserialised = JsonConvert.DeserializeObject(result);

                ((string)deserialised.name).Should().Be("Mick Hucknall");
            }
        }
Exemple #43
0
        public void FakeServer_ShouldExecuteResponseExpectationCallback_ReturnExpectedData()
        {
            const string expectedResult = "Some String Data";
            const string baseAddress    = "http://localhost:12354";

            const string url = "/some-url?id=1234";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get(url).Callback(() => new HttpResponseExpectation(HttpStatusCode.OK, expectedResult));

                fakeServer.Start();

                var result = new WebClient().DownloadString(new Uri(baseAddress + url));

                result.Should().Be(expectedResult);
            }
        }
        public async Task FakeServer_ExpectPutWithComplexBodyReturnsComplexObject()
        {
            const string expectedResult = "{\"Complex\":{\"Property1\":1,\"Property2\":true}}";
            const string body           = "{\"Complex\":1}";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Put("/some-path", body).Returns(HttpStatusCode.Created, expectedResult);
                fakeServer.Start();

                var result = await fakeServer.Client.PutAsync("/some-path", new StringContent(body));

                var content = await result.Content.ReadAsStringAsync();

                result.StatusCode.Should().Be(HttpStatusCode.Created);
                content.Should().Be(expectedResult);
            }
        }
        public async Task FakeServer_ExpectGetReturnsFileContent_ResponseMatchesExpectation()
        {
            const string path = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path)
                .ReturnsFromFile(@"TestData\TestResponse.json");

                fakeServer.Start();

                var result = await fakeServer.Client.GetStringAsync(path);

                dynamic deserialised = JsonConvert.DeserializeObject(result);

                ((string)deserialised.name).Should().Be("Mick Hucknall");
            }
        }
        public void FakeServer_ExpectGetReturnsObject_ResponseMatchesExpectation()
        {
            var expectedResult = new { RestaurantId = 1234 };
            const string baseAddress = "http://localhost:12354";

            const string url = "/restaurant/1234";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get(url).Returns(expectedResult);

                fakeServer.Start();

                var result = JsonConvert.DeserializeObject<dynamic>(new WebClient().DownloadString(new Uri(baseAddress + url)));

                Assert.Equal(expectedResult.RestaurantId, (int)result.RestaurantId);
            }
        }
        public void FakeServer_ExpectGetWithQueryParametersReturnsString_ResponseMatchesExpectation()
        {
            const string expectedResult = "Some String Data";
            const string baseAddress = "http://localhost:12354";
            
            const string url = "/some-url?id=1234";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get(url).Returns(expectedResult);

                fakeServer.Start();

                var uri = new Uri(baseAddress + url);
                var result = new WebClient().DownloadString(uri);

                result.Should().Be(expectedResult);
            }
        }
        public async Task FakeServer_ExpectPostWithPartialExpectedJsonBodyWithNestedElements_ResponseMatchesExpected()
        {
            const string expectedResult = "Some String Data";

            const string path = "/some-path";

            var content = new StringContent(@"{ Key: ""Value"", key2: { NestedKey1: ""NestedValue1"", NestedKey2: ""NestedValue2"" }, Key3: ""Value"" }");
            var expectedContent = @"{ Key: ""Value"", key2: { NestedKey1: ""NestedValue1"" } }";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Post(path, expectedContent).WithPartialJsonMatching().Returns(expectedResult);

                fakeServer.Start();

                var resp = await fakeServer.Client.PostAsync(path, content);
                var result = await resp.Content.ReadAsStringAsync();

                result.Should().Be(expectedResult);
            }
        }
        public async Task FakeServer_ExpectGetReturnsGeneratedTemplateFromPath_ResponseMatchesTemplate()
        {
            const string path = "/some-path";

            using (var fakeServer = new FakeServer())
            {
                fakeServer.Expect.Get(path)
                    .ReturnsFromTemplate(@"TestData\TestTemplate.json", new { Id = 2343, UserId = 2343, UserEmail = "*****@*****.**" })
                    .RespondsIn(TimeSpan.FromSeconds(1))
                    .WithHttpStatus(HttpStatusCode.Accepted);

                fakeServer.Start();

                var result = await fakeServer.Client.GetStringAsync(path);

                dynamic deserialised = JsonConvert.DeserializeObject(result);

                ((int)deserialised.id).Should().Be(2343);
                ((int)deserialised.userId).Should().Be(2343);
                ((string)deserialised.userEmail).Should().Be("*****@*****.**");
            }
        }
        public async Task FakeServer_ExpectGetWithHeadersSpecified_ResponseMatchesExpectionAndHasHeaders()
        {
            const string expectedResult = "Some String Data";

            var port = Ports.GetFreeTcpPort();

            var baseAddress = "http://localhost:" + port;

            const string url = "/some-url";

            using (var fakeServer = new FakeServer(port))
            {
                fakeServer.Expect.Get(url).Returns(expectedResult, new WebHeaderCollection { { "foo", "bar" } });
                fakeServer.Start();

                var client = new HttpClient {BaseAddress = new Uri(baseAddress)};
                var result = await client.GetAsync(url);

                result.Content.ReadAsStringAsync().Result.Should().Be(expectedResult);
                result.Headers.Should().ContainSingle(x => x.Key == "foo");
            }
        }
Exemple #51
0
        public void issue12693_repro()
        {
            var recordCount = 50;
            var random = new Random();
            var memoryStream = new MemoryStream();
            var csvWriter = new CsvWriter(memoryStream);

            // create some dummy data to work with
            for (var record = 0; record < recordCount; ++record)
            {
                var dataRecord = new DataRecord(null);

                for (var value = 0; value < random.Next(100, 200); ++value)
                {
                    dataRecord.Add("value" + random.Next(0, 100000));
                }

                csvWriter.WriteRecord(dataRecord);
            }

            memoryStream.Position = 0;

            // create a fake server that will feed us our dummy data in dribs and drabs
            using (var fakeServer = new FakeServer(memoryStream))
            using (var connectionToServer = new TcpClient("localhost", FakeServer.Port))
            using (var csvReader = new CsvReader(connectionToServer.GetStream()))
            {
                while (csvReader.HasMoreRecords)
                {
                    csvReader.ReadDataRecord();
                }

                // when the bug manifests itself, the parser may stop parsing prematurely so the record counts won't match
                // see below for an explanation of how the bug is triggered
                Assert.Equal(recordCount, csvReader.RecordNumber);
            }
        }
        public void FakeServer_ExpectGetToAnEndpointWithAFiveSecondResponseTime_ResponseTimeIsGreaterThanFiveSeconds()
        {
            var expectedResult = new { ResourceId = 1234 };
            const string baseAddress = "http://localhost:12354";
            var expectedResponseTime = TimeSpan.FromSeconds(5);

            const string fakeurl = "/some-url";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.ResponseTime = expectedResponseTime;
                fakeServer.Expect.Get(fakeurl).Returns(HttpStatusCode.OK, expectedResult);
                fakeServer.Start();

                var stopwatch = Stopwatch.StartNew();

                var t = new HttpClient().GetAsync(new Uri(baseAddress) + fakeurl);
                t.Wait();

                stopwatch.Stop();

                stopwatch.Elapsed.Should().BeGreaterOrEqualTo(expectedResponseTime);
            }
        }
        public void FakeServer_IgnoredParameter_Returns200()
        {
            var expectedResult = new { ResourceId = 1234 };
            const string baseAddress = "http://localhost:12354";

            const string fakeurl = "/some-resource/{ignore}/some-resource?date={ignore}&type={ignore}";
            const string actualurl = "/some-resource/1234/some-resource?date=2015-02-06T09:52:10&type=1";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get(fakeurl).Returns(HttpStatusCode.Accepted, expectedResult);
                fakeServer.Start();

                var t = new HttpClient().GetAsync(new Uri(baseAddress + actualurl));
                t.Wait();
                var result = t.Result;

                result.StatusCode.Should().Be(HttpStatusCode.Accepted);
            }
        }
        public void FakeServer_ExpectPutWithObjectBodyReturns201_Returns201()
        {
            var expectedResult = new {RestaurantId = 1234};
            const string baseAddress = "http://localhost:12354";

            const string url = "/some-url";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Put(url, string.Empty).Returns(HttpStatusCode.Created, expectedResult);
                fakeServer.Start();

                var t = new HttpClient().PutAsync(new Uri(baseAddress + url), new StringContent(String.Empty));
                t.Wait();
                var result = t.Result;

                result.StatusCode.Should().Be(HttpStatusCode.Created);
            }
        }
        public void FakeServer_ExpectPutWithComplexBodyReturnsComplexObject()
        {
            const string expectedResult = "{\"Complex\":{\"Property1\":1,\"Property2\":true}}";
            const string body = "{\"Complex\":1}";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Put("/some-url", body).Returns(HttpStatusCode.Created, expectedResult);
                fakeServer.Start();

                var t = new HttpClient().PutAsync(new Uri("http://localhost:12354" + "/some-url"), new StringContent(body));
                t.Wait();
                var result = t.Result;

                var resultTask = result.Content.ReadAsStringAsync();
                resultTask.Wait();

                result.StatusCode.Should().Be(HttpStatusCode.Created);
                resultTask.Result.Should().Be(expectedResult);
            }
        }
        public void FakeServer_ExpectPostWithMismatchingBody_Returns404()
        {
            const string expectedResult = "Some String Data";
            const string baseAddress = "http://localhost:12354";

            const string url = "/some-url";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Post(url, "jibberish").Returns(expectedResult);

                fakeServer.Start();

                var ex = Assert.Throws<WebException>(() => new WebClient().UploadString(new Uri(baseAddress + url), string.Empty));

                ((HttpWebResponse)ex.Response).StatusCode.Should().Be(HttpStatusCode.NotFound);
            }
        }
        public void FakeServer_ExpectGetWithMismatchingPath_Returns404()
        {
            const string expectedResult = "Some String Data";
            const string baseAddress = "http://localhost:12354";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get("/some-jibberish-url").Returns(expectedResult);

                fakeServer.Start();

                var ex = Assert.Throws<WebException>(() => new WebClient().DownloadString(new Uri(baseAddress + "/home")));

                ((HttpWebResponse)ex.Response).StatusCode.Should().Be(HttpStatusCode.NotFound);
            }
        }
        public void FakeServer_ShouldHandleMultipleRegistrationOnSameEndPoint_WithDifferentBodies_ReturnExpectedData()
        {
            var expectedResultA = "1234";
            var expectedResultB = "5678";

            const string baseAddress = "http://localhost:12354";
            const string fakeurl = "/some-url";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Post(fakeurl, "messageA").Returns(HttpStatusCode.OK, expectedResultA);
                fakeServer.Expect.Post(fakeurl, "messageB").Returns(HttpStatusCode.OK, expectedResultB);

                fakeServer.Start();

                var resultA = new WebClient().UploadString(new Uri(baseAddress + fakeurl), "POST", "messageA");
                var resultB = new WebClient().UploadString(new Uri(baseAddress + fakeurl), "POST", "messageB");

                resultA.Should().Be(expectedResultA);
                resultB.Should().Be(expectedResultB);
            }
        }
        public void FakeServer_ShouldExecuteResponseExpectationCallback_ReturnExpectedData()
        {
            const string expectedResult = "Some String Data";
            const string baseAddress = "http://localhost:12354";

            const string url = "/some-url?id=1234";

            using (var fakeServer = new FakeServer(12354))
            {
                fakeServer.Expect.Get(url).Callback(() => new HttpResponseExpectation(HttpStatusCode.OK, expectedResult));

                fakeServer.Start();

                var result = new WebClient().DownloadString(new Uri(baseAddress + url));

                result.Should().Be(expectedResult);
            }
        }
        public async Task FakeServer_CapturesAllRequests()
        {
            using (var fakeServer = new FakeServer())
            {
                fakeServer.Start();
                var baseAddress = fakeServer.BaseUri;
                
                var url1 = "/request1";
                var url2 = "/request2";
                var url3 = "/request3";
                var url4 = "/request4";

                var httpClient = new HttpClient();
                await httpClient.DeleteAsync(baseAddress + url1);
                await Repeat(() => httpClient.GetAsync(baseAddress + url2), 2);
                await Repeat(() => httpClient.PostAsync(baseAddress + url3, new StringContent(url3)), 3);
                await Repeat(() => httpClient.PutAsync(baseAddress + url4, new StringContent(url4)), 4);

                fakeServer.CapturedRequests.Count(x => x.Method == Http.Delete && x.Url == url1).Should().Be(1);
                fakeServer.CapturedRequests.Count(x => x.Method == Http.Get && x.Url == url2).Should().Be(2);
                fakeServer.CapturedRequests.Count(x => x.Method == Http.Post && x.Url == url3 && x.Body == url3).Should().Be(3);
                fakeServer.CapturedRequests.Count(x => x.Method == Http.Put && x.Url == url4 && x.Body == url4).Should().Be(4);
            }
        }