public void Can_get_an_artists_releases()
{
const string endpoint = "artist/releases";
var endPointInfo = new EndPointInfo
{
UriPath = endpoint,
Parameters = new Dictionary<string,string>
{
{ "artistId", "1" },
{ "pageSize", "100" }
}
};
var response = _requestCoordinator.HitEndpoint(endPointInfo);
dynamic dx = new DynamicXmlParser(XDocument.Parse(response.Body));
string [] titles = Enumerable.ToArray(Enumerable.Select<dynamic, string>(dx.releases.release, (Func<dynamic, string>) (r => r.title.value)));
foreach (var title in titles)
{
Console.WriteLine(title);
}
Assert.That(titles.Count(), Is.GreaterThan(0));
}
public XmlNode HitEndpoint(EndPointInfo endPointInfo)
{
string output = GetEndpointOutput(endPointInfo);
XmlNode response = GetResponseNode(output);
AssertError(response);
return response.FirstChild;
}
public XmlNode HitEndpoint(EndPointInfo endPointInfo)
{
string output = GetEndpointOutput(endPointInfo);
Debug.WriteLine(output);
XmlNode response = GetResponseNode(output);
AssertError(response);
return(response.FirstChild);
}
public void Should_not_care_how_many_times_you_create_an_endpoint()
{
var endPointState = new EndPointInfo
{
UriPath = "{slug}",
HttpMethod = "GET",
Parameters = new Dictionary<string, string> { { "slug", "something" } }
};
var result = _requestCoordinator.ConstructEndpoint(endPointState);
Assert.That(result, Is.EqualTo(_requestCoordinator.ConstructEndpoint(endPointState)));
}
private RequestHandler ConstructBuilder(EndPointInfo endPointInfo)
{
switch (endPointInfo.HttpMethod.ToUpperInvariant())
{
case "GET":
return new GetRequestHandler(_apiUri, _oAuthCredentials, _urlSigner);
case "POST":
return new PostRequestHandler(_apiUri, _oAuthCredentials, _urlSigner);
default:
throw new NotImplementedException();
}
}
private string GetEndpointOutput(EndPointInfo endPointInfo)
{
if (endPointInfo.UseHttps)
_apiUrl = _apiUrl.Replace("http://", "https://");
string uriString = string.Format("{0}/{1}?oauth_consumer_key={2}&{3}",
_apiUrl,
endPointInfo.Uri,
_consumerCredentials.ConsumerKey,
endPointInfo.Parameters.ToQueryString());
return GetResponse(uriString, endPointInfo.UserToken, endPointInfo.UserSecret);
}
private string GetEndpointOutput(EndPointInfo endPointInfo)
{
if (endPointInfo.UseHttps)
{
_apiUrl = _apiUrl.Replace("http://", "https://");
}
string uriString = string.Format("{0}/{1}?oauth_consumer_key={2}&{3}",
_apiUrl,
endPointInfo.Uri,
_consumerCredentials.ConsumerKey,
endPointInfo.Parameters.ToQueryString());
return(GetResponse(uriString, endPointInfo.UserToken, endPointInfo.UserSecret));
}
public void should_substitue_route_parameters()
{
var endpointInfo = new EndPointInfo
{
UriPath = "something/{route}",
Parameters = new Dictionary<string, string>
{
{"route","routevalue"}
}
};
var result = _requestCoordinator.ConstructEndpoint(endpointInfo);
Assert.That(result,Is.StringContaining("something/routevalue"));
}
private string GetEndpointOutput(EndPointInfo endPointInfo)
{
if (endPointInfo.UseHttps)
_apiUrl = _apiUrl.Replace("http://", "https://");
var uriString = string.Format("{0}/{1}?oauth_consumer_key={2}&{3}", _apiUrl, endPointInfo.Uri,
_consumerCredentials.ConsumerKey, endPointInfo.Parameters.ToQueryString()).TrimEnd('&');
var signedUrl = new Uri(uriString);
if(endPointInfo.IsSigned)
signedUrl = _urlSigner.SignUrl(uriString, endPointInfo.UserToken, endPointInfo.UserSecret, _consumerCredentials);
return _urlResolver.Resolve(signedUrl, endPointInfo.HttpMethod, new WebHeaderCollection());
}
public void Can_get_an_artists_releases()
{
const string endpoint = "artist/releases";
var endPointInfo = new EndPointInfo { Uri = endpoint, Parameters = new NameValueCollection { { "artistId", "1" } } };
string xml = _endpointResolver.GetRawXml(endPointInfo);
dynamic dx = new DynamicXmlParser(xml);
var name = dx.releases.release[0].title.Value;
var secondName = dx.releases.release[1].title.Value;
Assert.That(name, Is.EqualTo("Night Train"));
Assert.That(secondName, Is.EqualTo("Crystal Ball"));
}
public void Should_fire_resolve_with_correct_values()
{
A.CallTo(() => _urlResolver.Resolve(A<Uri>.Ignored, A<string>.Ignored, A<WebHeaderCollection>.Ignored))
.Returns("<response status=\"ok\" version=\"1.2\" ><serviceStatus><serverTime>2011-03-04T08:10:29Z</serverTime></serviceStatus></response>");
const string expectedMethod = "GET";
var expectedHeaders = new WebHeaderCollection();
var endPointState = new EndPointInfo() {Uri = "test", HttpMethod = expectedMethod, Headers = expectedHeaders};
var expected = new Uri(string.Format("{0}/test?oauth_consumer_key={1}", _apiUrl, _consumerKey));
_endpointResolver.HitEndpoint(endPointState);
A.CallTo(() => _urlResolver.Resolve(A<Uri>.That.Matches(x => x.PathAndQuery == expected.PathAndQuery), expectedMethod, A<WebHeaderCollection>.Ignored))
.MustHaveHappened();
}
public void Can_get_an_artist() {
const string endpoint = "artist/details";
var endPointInfo = new EndPointInfo { Uri = endpoint, Parameters = new Dictionary<string,string> { { "artistId", "1" } } };
string xml = _endpointResolver.HitEndpoint(endPointInfo);
dynamic dx = new DynamicXmlParser(XDocument.Parse(xml));
var name = dx.artist[0].name.value;
var sortName = dx.artist[0].sortName.value;
var url = dx.artist[0].url.value;
Assert.That(name, Is.EqualTo("Keane"));
Assert.That(sortName, Is.EqualTo("Keane"));
Assert.That(url, Is.StringStarting("http://www.7digital.com/artists/keane/"));
}
public void Can_get_an_artists_releases() {
const string endpoint = "artist/releases";
var endPointInfo = new EndPointInfo { Uri = endpoint, Parameters = new Dictionary<string,string> { { "artistId", "1" } } };
string xml = _endpointResolver.HitEndpoint(endPointInfo);
dynamic dx = new DynamicXmlParser(XDocument.Parse(xml));
string [] titles = Enumerable.ToArray(Enumerable.Select<dynamic, string>(dx.releases.release, (Func<dynamic, string>) (r => r.title.value)));
foreach (var title in titles) {
Console.WriteLine(title);
}
Assert.That(titles, Has.Member("Night Train").And.Member("Perfect Symmetry"));
}
public void Should_fire_resolve_with_correct_values()
{
A.CallTo(() => _httpClient.Get(A<GetRequest>.Ignored))
.Returns(new Response(HttpStatusCode.OK, SERVICE_STATUS));
const string expectedMethod = "GET";
var expectedHeaders = new Dictionary<string, string>();
var expected = string.Format("{0}/test?oauth_consumer_key={1}", API_URL, _consumerKey);
var endPointState = new EndPointInfo { UriPath = "test", HttpMethod = expectedMethod, Headers = expectedHeaders };
_requestCoordinator.HitEndpoint(endPointState);
A.CallTo(() => _httpClient
.Get(A<GetRequest>.That.Matches(y => y.Url == expected)))
.MustHaveHappened();
}
public void should_substitue_multiple_route_parameters()
{
var endpointInfo = new EndPointInfo
{
UriPath = "something/{firstRoute}/{secondRoute}/thrid/{thirdRoute}",
Parameters = new Dictionary<string, string>
{
{"firstRoute" , "firstValue"},
{"secondRoute","secondValue"},
{"thirdRoute" , "thirdValue"}
}
};
var result = _requestCoordinator.ConstructEndpoint(endpointInfo);
Assert.That(result, Is.StringContaining("something/firstvalue/secondvalue/thrid/thirdvalue"));
}
private Uri GetSignedUrl(EndPointInfo endPointInfo)
{
string apiUri = _apiUri.Uri;
if (endPointInfo.UseHttps)
apiUri = apiUri.Replace("http://", "https://");
var uriString = string.Format("{0}/{1}?oauth_consumer_key={2}&{3}",
apiUri, SubstituteRouteParameters(endPointInfo.Uri,endPointInfo.Parameters),
_oAuthCredentials.ConsumerKey,
endPointInfo.Parameters.ToQueryString()).TrimEnd('&');
var signedUrl = new Uri(uriString);
if (endPointInfo.IsSigned)
signedUrl = _urlSigner.SignUrl(uriString, endPointInfo.UserToken, endPointInfo.UserSecret, _oAuthCredentials);
return signedUrl;
}
public void routes_should_be_case_insensitive()
{
var endpointInfo = new EndPointInfo
{
UriPath = "something/{firstRoUte}/{secOndrouTe}/thrid/{tHirdRoute}",
Parameters = new Dictionary<string, string>
{
{"firstRoute" , "firstValue"},
{"secondRoute","secondValue"},
{"thirdRoute" , "thirdValue"}
}
};
var result = _requestCoordinator.ConstructEndpoint(endpointInfo);
Assert.That(result, Is.StringContaining("something/firstvalue/secondvalue/thrid/thirdvalue"));
}
public void Should_fire_resolve_with_correct_values()
{
A.CallTo(() => _urlResolver.Resolve(A<Uri>.Ignored, A<string>.Ignored, A<Dictionary<string, string>>.Ignored))
.Returns(SERVICE_STATUS);
const string expectedMethod = "GET";
var expectedHeaders = new Dictionary<string, string>();
var endPointState = new EndPointInfo { Uri = "test", HttpMethod = expectedMethod, Headers = expectedHeaders };
var expected = new Uri(string.Format("{0}/test?oauth_consumer_key={1}", API_URL, _consumerKey));
A.CallTo(() => _urlSigner.SignUrl(A<string>.Ignored, A<string>.Ignored, A<string>.Ignored, null)).Returns(expected);
_endpointResolver.HitEndpoint(endPointState);
A.CallTo(() => _urlResolver
.Resolve(A<Uri>.That.Matches(x => x.PathAndQuery == expected.PathAndQuery), expectedMethod, A<Dictionary<string, string>>.Ignored))
.MustHaveHappened();
}
public void Should_fire_resolve_with_url_encoded_parameters()
{
A.CallTo(() => _httpClient.Get(A<GetRequest>.Ignored))
.Returns(new Response(HttpStatusCode.OK, SERVICE_STATUS));
const string unEncodedParameterValue = "Alive & Amplified";
const string expectedParameterValue = "Alive%20%26%20Amplified";
var expectedHeaders = new Dictionary<string, string>();
var testParameters = new Dictionary<string, string> { { "q", unEncodedParameterValue } };
var expected = string.Format("{0}/test?oauth_consumer_key={1}&q={2}", API_URL, _consumerKey, expectedParameterValue);
var endPointState = new EndPointInfo { UriPath = "test", HttpMethod = "GET", Headers = expectedHeaders, Parameters = testParameters };
_requestCoordinator.HitEndpoint(endPointState);
A.CallTo(() => _httpClient
.Get(A<GetRequest>.That.Matches(y => y.Url == expected)))
.MustHaveHappened();
}
public string GetRawXml(EndPointInfo endPointInfo)
{
return GetEndpointOutput(endPointInfo);
}
public void Should_use_api_uri_provided_by_IApiUri_interface()
{
const string expectedApiUri = "http://api.7dizzle";
Given_a_urlresolver_that_returns_valid_xml();
var apiUri = A.Fake<IApiUri>();
A.CallTo(() => apiUri.Uri).Returns(expectedApiUri);
IOAuthCredentials oAuthCredentials = EssentialDependencyCheck<IOAuthCredentials>.Instance;
var endpointResolver = new EndpointResolver(_urlResolver, _urlSigner, oAuthCredentials, apiUri);
var endPointState = new EndPointInfo { Uri = "test", HttpMethod = "GET", Headers = new Dictionary<string, string>() };
endpointResolver.HitEndpoint(endPointState);
A.CallTo(() => apiUri.Uri).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => _urlResolver.Resolve(
A<Uri>.That.Matches(x => x.ToString().Contains(expectedApiUri)),
A<string>.Ignored, A<Dictionary<string, string>>.Ignored))
.MustHaveHappened(Repeated.Exactly.Once);
}
public string ConstructEndpoint(EndPointInfo endPointInfo) {
return GetSignedUrl(endPointInfo).ToString();
}
public Response HitEndpoint(EndPointInfo endPointInfo)
{
throw new NotImplementedException();
}
public string GetRawXml(EndPointInfo endPointInfo)
{
return(GetEndpointOutput(endPointInfo));
}
public void HitEndpointAsync(EndPointInfo endPointInfo, Action<Response> callback)
{
callback(StubPayload);
}
public virtual IResponse HitEndpoint(EndPointInfo endPointInfo)
{
var builder = ConstructBuilder(endPointInfo);
builder.HttpClient = HttpClient;
return builder.HitEndpoint(endPointInfo);
}
public void HitEndpointAsync(EndPointInfo endPointInfo, Action<string> payload)
{
payload(StubPayload);
}
public string ConstructEndpoint(EndPointInfo endPointInfo)
{
return ConstructBuilder(endPointInfo).ConstructEndpoint(endPointInfo);
}
public virtual string HitEndpoint(EndPointInfo endPointInfo)
{
Uri signedUrl = GetSignedUrl(endPointInfo);
return _urlResolver.Resolve(signedUrl, endPointInfo.HttpMethod, new Dictionary<string, string>());
}
public void should_remove_parameters_that_match()
{
var endpointInfo = new EndPointInfo
{
UriPath = "something/{route-66}",
Parameters = new Dictionary<string, string>
{
{"route-66","routevalue"}
}
};
var result = _requestCoordinator.ConstructEndpoint(endpointInfo);
Assert.That(result, Is.Not.StringContaining("route-66=routevalue"));
}
public virtual void HitEndpointAsync(EndPointInfo endPointInfo, Action<string> payload)
{
Uri signedUrl = GetSignedUrl(endPointInfo);
_urlResolver.ResolveAsync(signedUrl, endPointInfo.HttpMethod, new Dictionary<string, string>(), payload);
}
public virtual void HitEndpointAsync(EndPointInfo endPointInfo, Action<IResponse> callback)
{
var builder = ConstructBuilder(endPointInfo);
builder.HttpClient = HttpClient;
builder.HitEndpointAsync(endPointInfo, callback);
}
public string ConstructEndpoint(EndPointInfo endPointInfo)
{
throw new NotImplementedException();
}
