public static IService CreateDefaultService()
{
IService service = RamoneConfiguration.NewService(TestHelper.BaseUrl);
service.DefaultEncoding = Encoding.GetEncoding("iso-8859-1");
ICodecManager cm = service.CodecManager;
cm.AddCodec <Dossier, XmlSerializerCodec>(CMSConstants.CMSMediaType);
cm.AddCodec <DossierDocumentList, XmlSerializerCodec>(CMSConstants.CMSMediaType);
cm.AddCodec <Document, XmlSerializerCodec>(CMSConstants.CMSMediaType);
cm.AddCodec <Party, XmlSerializerCodec>(CMSConstants.CMSMediaType);
cm.AddCodec <Cat, CatAsTextCodec>(MediaType.TextPlain);
cm.AddCodec <Cat, CatAsHtmlCodec>(MediaType.TextHtml);
cm.AddCodec <Dog1, XmlSerializerCodec>(new MediaType("application/vnd.dog+xml"));
cm.AddCodec <Dog2, XmlSerializerCodec>(new MediaType("application/vnd.dog+xml"));
cm.AddCodec <HeaderList, XmlSerializerCodec>(MediaType.ApplicationXml);
cm.AddCodec <RegisteredClass, XmlSerializerCodec>(MediaType.ApplicationXml);
return(service);
}
public void WhenCreatingSessionItClonesAuthorizationDispatcher()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
// Act
ISession session1 = service.NewSession();
service.AuthorizationDispatcher.Add("dummy1", new DummyHandler1());
ISession session2 = service.NewSession();
session2.AuthorizationDispatcher.Add("dummy2", new DummyHandler2());
ISession session3 = service.NewSession();
// Assert
Assert.IsNull(session1.AuthorizationDispatcher.Get("dummy1"));
Assert.IsNull(session1.AuthorizationDispatcher.Get("dummy2"));
Assert.IsNotNull(session2.AuthorizationDispatcher.Get("dummy1"));
Assert.IsNotNull(session2.AuthorizationDispatcher.Get("dummy2"));
Assert.IsNotNull(session3.AuthorizationDispatcher.Get("dummy1"));
Assert.IsNull(session3.AuthorizationDispatcher.Get("dummy2"));
}
public static void Initialize()
{
HtmlNode.ElementsFlags.Remove("form");
HtmlNode.ElementsFlags.Add("form", HtmlElementFlag.CanOverlap);
RamoneConfiguration.AddCodecRegistrator(new HtmlCodecRegistrator());
}
static void Main(string[] args)
{
Request req = RamoneConfiguration.NewSession(new Uri("http://www.dr.dk")).Bind("/");
using (var resp = req.Get())
{
}
}
static RamoneServiceManager()
{
Service = RamoneConfiguration.NewService();
Service.UserAgent = "API Explorer";
Service.CodecManager.AddCodec <JsonNetCodec>(new MediaType("application/vnd.mason+json"));
Session = Service.NewSession();
}
public void WhenNotUsingBaseUrlItThrowsInvalidOperationException()
{
// Act
ISession session = RamoneConfiguration.NewSession();
AssertThrows <InvalidOperationException>(
() => session.Bind(DossierTemplate, new { id = 2 }),
ex => ex.Message.Contains("base URL"));
}
/// <summary>
/// Executed before each test method is run. Override in subclasses to do subclass
/// set up. Remember to call base.SetUp().
/// NOTE: The [SetUp] attribute cannot be used in subclasses because it is already
/// in use.
/// </summary>
protected virtual void SetUp()
{
RamoneConfiguration.Reset();
AtomInitializer.Initialize();
HtmlInitializer.Initialize();
// Create a new session for each test
Session = TestService.NewSession();
}
public void WhenCreatingSessionItClonesSerializerSettings()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
service.SerializerSettings.ArrayFormat = "A";
service.SerializerSettings.DictionaryFormat = "B";
service.SerializerSettings.PropertyFormat = "C";
service.SerializerSettings.DateTimeFormat = "O";
service.SerializerSettings.Formaters.AddFormater(typeof(SomeClass1), new SomeClass1Formater());
service.SerializerSettings.Culture = CultureInfo.GetCultureInfo("da-DK");
service.SerializerSettings.Encoding = Encoding.ASCII;
service.SerializerSettings.EnableNonAsciiCharactersInMultipartFilenames = true;
// Act 1
ISession session = service.NewSession();
// Assert
Assert.AreEqual("A", session.SerializerSettings.ArrayFormat);
Assert.AreEqual("B", session.SerializerSettings.DictionaryFormat);
Assert.AreEqual("C", session.SerializerSettings.PropertyFormat);
Assert.AreEqual("O", session.SerializerSettings.DateTimeFormat);
Assert.AreEqual("da-DK", session.SerializerSettings.Culture.Name);
Assert.AreEqual(Encoding.ASCII, session.SerializerSettings.Encoding);
Assert.IsTrue(session.SerializerSettings.EnableNonAsciiCharactersInMultipartFilenames);
// Act 2
session.SerializerSettings.ArrayFormat = "A2";
session.SerializerSettings.DictionaryFormat = "B2";
session.SerializerSettings.PropertyFormat = "C2";
session.SerializerSettings.DateTimeFormat = "R";
session.SerializerSettings.Formaters.AddFormater(typeof(SomeClass2), new SomeClass2Formater());
session.SerializerSettings.Culture = CultureInfo.GetCultureInfo("pt-BR");
session.SerializerSettings.Encoding = Encoding.Unicode;
session.SerializerSettings.EnableNonAsciiCharactersInMultipartFilenames = false;
// Assert
Assert.AreEqual("A2", session.SerializerSettings.ArrayFormat);
Assert.AreEqual("B2", session.SerializerSettings.DictionaryFormat);
Assert.AreEqual("C2", session.SerializerSettings.PropertyFormat);
Assert.AreEqual("R", session.SerializerSettings.DateTimeFormat);
Assert.AreEqual("pt-BR", session.SerializerSettings.Culture.Name);
Assert.AreEqual(Encoding.Unicode, session.SerializerSettings.Encoding);
Assert.IsFalse(session.SerializerSettings.EnableNonAsciiCharactersInMultipartFilenames);
Assert.AreEqual("A", service.SerializerSettings.ArrayFormat);
Assert.AreEqual("B", service.SerializerSettings.DictionaryFormat);
Assert.AreEqual("C", service.SerializerSettings.PropertyFormat);
Assert.AreEqual("O", service.SerializerSettings.DateTimeFormat);
Assert.AreEqual("da-DK", service.SerializerSettings.Culture.Name);
Assert.AreEqual(Encoding.ASCII, service.SerializerSettings.Encoding);
Assert.IsTrue(service.SerializerSettings.EnableNonAsciiCharactersInMultipartFilenames);
Assert.IsNotNull(session.SerializerSettings.Formaters.GetFormater(typeof(SomeClass1)));
Assert.IsNotNull(session.SerializerSettings.Formaters.GetFormater(typeof(SomeClass2)));
Assert.IsNotNull(service.SerializerSettings.Formaters.GetFormater(typeof(SomeClass1)));
Assert.IsNull(service.SerializerSettings.Formaters.GetFormater(typeof(SomeClass2)));
}
public void CanSkipUseOfService()
{
// Act
ISession session = RamoneConfiguration.NewSession(BaseUrl);
// Assert
Assert.IsNotNull(session.Service);
Assert.IsNotNull(session.Service.BaseUri);
Assert.AreEqual(BaseUrl, BaseUrl.AbsoluteUri);
}
public void Setup()
{
TestHelper.TestService = RamoneConfiguration.NewService(TestHelper.BaseUrl);
TestHelper.TestService.DefaultEncoding = Encoding.GetEncoding("iso-8859-1");
// FIXME: move this to some utility feature in Hypermedia namespace
TestHelper.TestService.CodecManager.AddCodec <Resource, MasonCodec>(new MediaType("application/vnd.mason+json"));
ICodecManager cm = TestHelper.TestService.CodecManager;
}
static void Setup()
{
// Create new session with implicit service
Session = RamoneConfiguration.NewSession(new Uri("https://api.twitter.com"));
// Set default request/response media-types to UrlEncoded/JSON for Twitter.
// This saves us the hassle of specifying codecs for all the Twitter resource types (Tweet, Timeline, User etc.)
Session.DefaultRequestMediaType = MediaType.ApplicationFormUrlEncoded;
Session.DefaultResponseMediaType = MediaType.ApplicationJson;
}
public void CanAvoidAddingStandardCodecs()
{
// Act
RamoneConfiguration.UseStandardCodecs = false;
IService service = RamoneConfiguration.NewService(BaseUrl);
// Assert (a few of them)
AssertThrows <ArgumentException>(() => service.CodecManager.GetReader(typeof(XmlDocument), MediaType.ApplicationXml));
AssertThrows <ArgumentException>(() => service.CodecManager.GetReader(typeof(Stream), MediaType.ApplicationOctetStream));
AssertThrows <ArgumentException>(() => service.CodecManager.GetWriter(typeof(Stream), new MediaType("unknown/other")));
}
public void CanSetAndGetServiceItems()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
// Act
service.Items["X"] = 1234;
int x = (int)service.Items["X"];
// Assert
Assert.AreEqual(1234, x);
}
public void CanConfigureSimpleProperties()
{
// Act
RamoneConfiguration.UserAgent = "Tester";
RamoneConfiguration.DefaultEncoding = Encoding.ASCII;
IService service = RamoneConfiguration.NewService(BaseUrl);
// Assert
Assert.AreEqual("Tester", service.UserAgent);
Assert.AreEqual(Encoding.ASCII, service.DefaultEncoding);
}
public void CanAddAuthorizerToService()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
// Act
service.BasicAuthentication("John", "magic");
ISession session = service.NewSession();
Response response = session.Request(BasicAuthUrl).Get();
// Assert
Assert.IsNotNull(response);
}
public void HasExpectedDefaultSettings()
{
// Act
IService service = RamoneConfiguration.NewService(BaseUrl);
// Assert
Assert.AreEqual("Ramone/1.0", service.UserAgent);
Assert.AreEqual(Encoding.UTF8, service.DefaultEncoding);
Assert.AreEqual("{0}[{1}]", service.SerializerSettings.ArrayFormat);
Assert.AreEqual("{0}[{1}]", service.SerializerSettings.DictionaryFormat);
Assert.AreEqual("{0}.{1}", service.SerializerSettings.PropertyFormat);
Assert.AreEqual("s", service.SerializerSettings.DateTimeFormat);
Assert.AreEqual(CultureInfo.InvariantCulture.Name, service.SerializerSettings.Culture.Name);
}
public void WhenCreatingSessionItInheritsServiceItems()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
service.Items["X"] = 1234;
// Act
ISession session = service.NewSession();
int x = (int)session.Items["X"];
// Assert
Assert.AreEqual(1234, x);
}
public void CanAddAuthorizerWithInternationalLettersToService()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
// Act
service.BasicAuthentication("Jürgen Wølst", "hmpf");
ISession session = service.NewSession();
using (Response response = session.Request(BasicAuthUrl).Get())
{
// Assert
Assert.IsNotNull(response);
}
}
public void CanCreateSessionWithoutBaseUrlAndMakeAbsoluteRequests()
{
// Act
ISession session = RamoneConfiguration.NewSession();
session.Service.CodecManager.AddCodec <Dossier, XmlSerializerCodec>(CMSConstants.CMSMediaType);
Request req = session.Bind(new Uri(BaseUrl, CMSConstants.DossierPath.Replace("{id}", "0")));
using (var resp = req.Get <Dossier>())
{
// Assert
Assert.IsNotNull(resp.Body);
Assert.AreEqual(0, resp.Body.Id);
}
}
public void WhenChangingItemsInSessionItDoesNotChangeItemsInService()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
service.Items["X"] = 1234;
ISession session = service.NewSession();
// Act
session.Items["Y"] = "Hello";
session.Items.Remove("X");
// Assert
Assert.AreEqual(1234, (int)service.Items["X"]);
Assert.IsFalse(service.Items.ContainsKey("Y"));
}
public void CanAssignCachePolicyToService()
{
// Act
IService service = RamoneConfiguration.NewService(TestHelper.BaseUrl);
service.CachePolicy = Policy;
ISession session = service.NewSession();
Request request = session.Request(HeaderListUrl);
// Assert
RequestCachePolicy policy = null;
using (request.OnHeadersReady(r => policy = r.CachePolicy).AcceptXml().Get <HeaderList>())
{
Assert.AreEqual(Policy, policy);
}
}
public void CanConfigureSerializerSettings()
{
// Act
RamoneConfiguration.SerializerSettings.ArrayFormat = "A";
RamoneConfiguration.SerializerSettings.DictionaryFormat = "B";
RamoneConfiguration.SerializerSettings.PropertyFormat = "C";
RamoneConfiguration.SerializerSettings.DateTimeFormat = "O";
RamoneConfiguration.SerializerSettings.Culture = CultureInfo.GetCultureInfo("da-DK");
IService service = RamoneConfiguration.NewService(BaseUrl);
// Assert
Assert.AreEqual("A", service.SerializerSettings.ArrayFormat);
Assert.AreEqual("B", service.SerializerSettings.DictionaryFormat);
Assert.AreEqual("C", service.SerializerSettings.PropertyFormat);
Assert.AreEqual("O", service.SerializerSettings.DateTimeFormat);
Assert.AreEqual("da-DK", service.SerializerSettings.Culture.Name);
}
static void Setup()
{
// Create new session with implicit service
Session = RamoneConfiguration.NewSession(new Uri(GoogleAPIBaseUrl));
// Get Google API keys from file (don't want the secret parts hardcoded in public repository)
GoogleKeys keys = new GoogleKeys();
if (SelectedAccessType != AccessType.JWT)
{
keys = ReadKeys();
}
// Configure OAuth2 with the stuff it needs for it's magic
OAuth2Settings settings = new OAuth2Settings
{
TokenEndpoint = new Uri(TokenEndpointUrl)
};
if (SelectedAccessType == AccessType.PinCode)
{
settings.AuthorizationEndpoint = new Uri(AuthorizationEndpointUrl);
settings.RedirectUri = new Uri("urn:ietf:wg:oauth:2.0:oob");
settings.ClientID = keys.ClientId;
settings.ClientSecret = keys.ClientSecret;
settings.ClientAuthenticationMethod = OAuth2Settings.DefaultClientAuthenticationMethods.RequestBody;
}
else if (SelectedAccessType == AccessType.Redirect)
{
settings.AuthorizationEndpoint = new Uri(AuthorizationEndpointUrl);
settings.RedirectUri = new Uri("http://localhost");
settings.ClientID = keys.ClientId;
settings.ClientSecret = keys.ClientSecret;
settings.ClientAuthenticationMethod = OAuth2Settings.DefaultClientAuthenticationMethods.RequestBody;
}
else
{
settings.ClientAuthenticationMethod = OAuth2Settings.DefaultClientAuthenticationMethods.Other;
}
Session.OAuth2_Configure(settings);
}
public void WhenCreatingSessionItCopiesAllSimpleProperties()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
service.UserAgent = "Dummy";
service.DefaultEncoding = Encoding.ASCII;
service.DefaultRequestMediaType = new MediaType("X/1");
service.DefaultResponseMediaType = new MediaType("Y/1");
// Act
ISession session = service.NewSession();
// Assert
Assert.AreEqual("Dummy", session.UserAgent);
Assert.AreEqual(Encoding.ASCII, session.DefaultEncoding);
Assert.AreEqual(new MediaType("X/1"), session.DefaultRequestMediaType);
Assert.AreEqual(new MediaType("Y/1"), session.DefaultResponseMediaType);
Assert.AreEqual(BaseUrl, session.BaseUri);
}
public void HasStandardCodec()
{
// Act
IService service = RamoneConfiguration.NewService(BaseUrl);
// Assert (a few of them)
Assert.IsNotNull(service.CodecManager.GetReader(typeof(XmlDocument), MediaType.ApplicationXml));
Assert.IsNotNull(service.CodecManager.GetReader(typeof(object), MediaType.ApplicationJson));
Assert.IsNotNull(service.CodecManager.GetReader(typeof(SyndicationFeed), MediaType.ApplicationAtom));
// Streams can read/write any media-type
Assert.IsNotNull(service.CodecManager.GetReader(typeof(Stream), MediaType.ApplicationOctetStream));
Assert.IsNotNull(service.CodecManager.GetReader(typeof(Stream), new MediaType("image/jpeg")));
Assert.IsNotNull(service.CodecManager.GetReader(typeof(Stream), new MediaType("unknown/other")));
// Writers
Assert.IsNotNull(service.CodecManager.GetWriter(typeof(Stream), MediaType.ApplicationOctetStream));
Assert.IsNotNull(service.CodecManager.GetWriter(typeof(Stream), new MediaType("image/jpeg")));
Assert.IsNotNull(service.CodecManager.GetWriter(typeof(Stream), new MediaType("unknown/other")));
}
public void ItUsesMultipleDefaultAcceptFromServiceWithAdditionalAcceptFromRequest()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl)
.AlwaysAccept(MediaType.ApplicationXml, 0.88)
.AlwaysAccept(MediaType.TextPlain);
ISession session = service.NewSession().AlwaysAccept(MediaType.TextHtml);
// Act
var request = session.Bind(HeaderListUrl).Accept(MediaType.ApplicationJson).Accept("text/csv", 0.21);
using (var r = request.Get <HeaderList>())
{
HeaderList headers = r.Body;
// Assert
Assert.IsTrue(headers.Any(h => h == "Accept: application/json, text/csv; q=0.21, application/xml; q=0.88, text/plain, text/html"), "Must contain Accept header with q-value");
}
}
public void WhenCreatingSessionItClonesRedirectSettings()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
// Act
ISession session1 = service.NewSession();
service.SetAllowedRedirects(300, 11);
ISession session2 = service.NewSession();
session2.SetAllowedRedirects(301, 7);
ISession session3 = service.NewSession();
// Assert
Assert.AreEqual(11, service.GetAllowedRedirects(300));
Assert.AreEqual(0, session1.GetAllowedRedirects(300));
Assert.AreEqual(11, session2.GetAllowedRedirects(300));
Assert.AreEqual(7, session2.GetAllowedRedirects(301));
}
public void CanSerializeWithStandardFormaters()
{
// Arrange
RamoneConfiguration.RegisterStandardSerializationFormaters(MyObjectSerializerFormaterManager);
var o = new
{
Bool = false,
Date = new DateTime(2012, 10, 12, 15, 14, 13),
Url = new Uri("http://dr.dk")
};
// Act
ObjectSerializerSettings settings = new ObjectSerializerSettings
{
Formaters = MyObjectSerializerFormaterManager
};
string result = Serialize(o, settings);
// Assert
Assert.AreEqual("|Bool=False|Date=2012-10-12T15:14:13|Url=http://dr.dk/", result);
}
public void WhenPostingFormUrlEncodedItAssignsCorrectContentLength_WhichMeans_DoNotIncludeByteOrderMarks()
{
// Arrange
ISession localSession = RamoneConfiguration.NewSession(BaseUrl);
Request request = localSession.Bind(Constants.HeaderEchoPath).AsFormUrlEncoded();
var registrations = new
{
f = "json"
};
// Act
using (var r = request.Post(registrations))
{
HeaderList headers = r.Decode <HeaderList>();
// Assert
string header = headers.FirstOrDefault(h => h == "Content-Length: 6");
Assert.IsNotNull(header, "Must send 6 bytes of data (should not include byte order marks)");
Console.WriteLine(header);
}
}
public void WhenCreatingSessionItClonesInterceptors()
{
// Arrange
IService service = RamoneConfiguration.NewService(BaseUrl);
// Act
ISession session1 = service.NewSession();
service.RequestInterceptors.Add(new DummyInterceptor1());
ISession session2 = service.NewSession();
session2.RequestInterceptors.Add(new DummyInterceptor2());
ISession session3 = service.NewSession();
// Assert
Assert.AreEqual(0, session1.RequestInterceptors.Count());
Assert.AreEqual(2, session2.RequestInterceptors.Count());
Assert.AreEqual(1, session3.RequestInterceptors.Count());
}
