public void Register_WhenProvidedWithANonDefaultDomain_CreatesANewPageOnThatDomain(WireDataFormat format)
        {
            var client = TestContext.CreateClientValidRflCredentials(format);
            var domain = TestConfigurationsHelper.GetProperty<ITestConfigurations, string>(x => x.RflDomain);
            client.SetWhiteLabelDomain(domain);

			var pageClient = new PageApi(client.HttpChannel);
            
            var pageShortName = "api-test-" + Guid.NewGuid();
            
            var pageCreationRequest = new RegisterPageRequest
            {
                ActivityType = null,
                Attribution =  null,
                CharityId = 2050,
                PageShortName = pageShortName,
                PageTitle = "Page created on domain " + domain + " by an integration test",
                EventDate = null,
                EventName = null,
                EventId = TestConfigurationsHelper.GetProperty<ITestConfigurations, int>(x => x.RflEventReference), //Was 1 for local
                TargetAmount = null
            };

            var registrationResponse = pageClient.Create(pageCreationRequest);

            Assert.That(registrationResponse.Next.Uri, Is.StringContaining(domain));
        }

        public void RegisterWhenProvidedWithADomainThatDoesNotExist_ThrowsException(WireDataFormat format)
        {
            const string domainThatDoesNotExistOnJustGiving = "Incorrect.com";

            var client = TestContext.CreateClientValidCredentials(format);
            client.SetWhiteLabelDomain(domainThatDoesNotExistOnJustGiving);

            var pageClient = new PageApi(client.HttpChannel);
            var pageShortName = "api-test-" + Guid.NewGuid();
            var pageCreationRequest = new RegisterPageRequest
            {
                ActivityType = null,
                PageShortName = pageShortName,
                PageTitle = "api test",
                EventName = "The Other Occasion of ApTest and APITest",
                CharityId = 2050,
                EventId = 1,
                TargetAmount = 20M,
                EventDate = DateTime.Now.AddDays(5)
            };

            var exception = Assert.Throws<ErrorResponseException>(() => pageClient.Create(pageCreationRequest));

            Assert.That(exception.Response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
        }

        public void ListAllPages_WhenSuppliedEmailIsValid_ListsPages(WireDataFormat format)
        {
            var client = TestContext.CreateClientInvalidCredentials(format);
			var accountClient = new AccountApi(client.HttpChannel);

            accountClient.ListAllPages("[email protected]");
        }

        public void RetrievePages_IssuedWithKnownIdAndPage2_ReturnsPages(WireDataFormat format)
        {
            var client = TestContext.CreateClientNoCredentials(format);
			var eventApi = new EventApi(client.HttpChannel);

            eventApi.RetrievePages(479546, 20, 2); // VLM 2011 on local dev
        }

        public void RetrieveEvent_IssuedWithKnownId_ReturnsEvent(WireDataFormat format)
        {
            var client = TestContext.CreateClientNoCredentials(format);
			var eventApi = new EventApi(client.HttpChannel);

            eventApi.Retrieve(479546); // VLM 2011 on local dev
        }

        public void RetrieveEvents_WhenDoesntSuppliedCredentials_ReturnsEvents(WireDataFormat format)
        {
            var client = TestContext.CreateClientNoCredentials(format);
			var charityClient = new CharityApi(client.HttpChannel);
            var response = charityClient.RetrieveEvents(2357);
            Assert.That(response, Is.Not.Null);
            Assert.That(response.CharityId, Is.Not.EqualTo(0));
        }

 public void InMemorySearch_KeywordWithKnownResults_SearchResultsPresent(WireDataFormat format)
 {
     var client = TestContext.CreateClientNoCredentials(format);
     var searchClient = new SearchApi(client.HttpChannel);
     
     var items = searchClient.InMemorySearch(null, "James", "Morrison", null);
     Assert.IsTrue(items.Results.Any());
 }

        public void EventSearch_KeywordWithKnownResults_SearchResultsPresent(WireDataFormat format)
        {
            var client = TestContext.CreateClientNoCredentials(format);
            var searchClient = new SearchApi(client.HttpChannel);

            var items = searchClient.EventSearch("Test");
            Assert.IsTrue(items.Results.Any());
        }

		public void TeamExists_AndATeamDoesntExist_ReturnsFalse(WireDataFormat format)
        {
			WithAValidClient(format);
			
			var existsResponse = _api.TeamExists(Guid.NewGuid().ToString());

			Assert.That(existsResponse, Is.False);
        }

        public void ResourceExists_ReturnsPayment(WireDataFormat format, bool isZipSupported)
        {
            var clientConfiguration = GetDefaultDataClientConfiguration()
               .With((clientConfig) => clientConfig.WireDataFormat = format)
               .With((clientConfig) => clientConfig.IsZipSupportedByClient = isZipSupported);

            Assert.IsNotNull(GetPayment(clientConfiguration));
        }

        public void IsEmailRegistered_WhenSuppliedKnownEmail_ReturnsTrue(WireDataFormat format)
        {
            var client = TestContext.CreateClientInvalidCredentials(format);
			var accountClient = new AccountApi(client.HttpChannel);

            var exists = accountClient.IsEmailRegistered(TestContext.TestUsername);

            Assert.IsTrue(exists);
        }

        public void GetDonationStatus_WhenSuppliedWithKnownExistingDonationId_ReturnsDonationStatus(WireDataFormat format)
        {
            var client = TestContext.CreateClientValidCredentials(format);
            var donationClient = new DonationApi(client.HttpChannel);

            var status = donationClient.RetrieveStatus(20905200);

            Assert.IsNotNull(status);
        }

        public void IsEmailRegistered_WhenSuppliedEmailUnlikelyToExist_ReturnsFalse(WireDataFormat format)
        {
            var client = TestContext.CreateClientInvalidCredentials(format);
			var accountClient = new AccountApi(client.HttpChannel);

            var exists = accountClient.IsEmailRegistered(Guid.NewGuid().ToString() + "@justgiving.com"); 

            Assert.IsFalse(exists);
        }

 public static JustGivingClient CreateClientValidRflCredentials(WireDataFormat wireDataFormat)
 {
     var cfg = new ClientConfiguration(ApiLocation, ApiKey, 1)
     {
         Username = RflUserName,
         Password = TestValidPassword,
         WireDataFormat = wireDataFormat
     };
     return new JustGivingClient(cfg);
 }

        public void GetRememberPersonCollectionData_WhenProvidedWithValidPersonId_ReturnsRememberPersonCollectionData(WireDataFormat format)
        {
            var client = TestContext.CreateClientValidCredentials(format);
            var inMemoryClient = new InMemoryApi(client.HttpChannel);
            int rememberPersonId = 71;

            var retrieveCollectionData = inMemoryClient.RetrieveCollectionData(rememberPersonId);

            Assert.Greater(retrieveCollectionData.Pages.Length, 0);
        }

        public void GetRememberPerson_WhenProvidedWithValidPersonId_ReturnsRememberPersonDetails(WireDataFormat format)
        {
            var client = TestContext.CreateClientValidCredentials(format);
			var inMemoryClient = new InMemoryApi(client.HttpChannel);
            int rememberPersonId = 71;

            var response = inMemoryClient.Retrieve(rememberPersonId);

            Assert.AreEqual(response.RememberedPerson.Id, rememberPersonId);
            Assert.That(response.CollectionUri, Is.StringContaining(string.Format("remember/{0}/", response.RememberedPerson.Id)));
        }

        public static JustGivingClient CreateClientValidCredentials(WireDataFormat wireDataFormat, string username = null, string password = null)
        {
            var cfg = new ClientConfiguration(ApiLocation, ApiKey, 1)
            {
                Username = username ?? TestUsername,
                Password = password ?? TestValidPassword,
                WireDataFormat = wireDataFormat
            };

            return new JustGivingClient(cfg);
        }

        public void Register_WhenSuppliedEmailIsUnused_AccountIsCreatedAndEmailAddressReturned(WireDataFormat format)
        {
            var client = TestContext.CreateClientInvalidCredentials(format);
			var accountClient = new AccountApi(client.HttpChannel);
            var email = Guid.NewGuid() + "@tempuri.org";
            var request = CreateValidRegisterAccountRequest(email);

            var registeredUsersEmail = accountClient.Create(request);

            Assert.AreEqual(email, registeredUsersEmail);
        }

        public void InMemorySearch_KeywordWithOnlyLastName_ReturnsError_NotingFirstNameIsMandatory(WireDataFormat format)
        {
            var client = TestContext.CreateClientNoCredentials(format);
            var searchClient = new SearchApi(client.HttpChannel);

            var exception = Assert.Throws<ErrorResponseException>(() => searchClient.InMemorySearch(null, null, "Morrison", null));

            Assert.That(exception.Errors.Count, Is.EqualTo(1));
            Assert.That(exception.Errors[0].Id, Is.EqualTo("InvalidFirstName"));
            Assert.That(exception.Errors[0].Description, Is.EqualTo("The first name of the person you're remembering cannot be empty."));
        }

        public void RetrieveCharity_IssuedWithKnownId_ReturnsCharity(WireDataFormat format)
        {
            var client = TestContext.CreateClientNoCredentials(format);
			var charityClient = new CharityApi(client.HttpChannel);

            var item = charityClient.Retrieve(2050);

            Assert.IsNotNull(item);
            Assert.That(item.Name, Is.StringContaining("The Demo Charity"));
            Assert.That(item.SmsShortName, Is.StringMatching("Your Charity Campaign"));
        }