Added tests for nodes operations

Author: gpailler

MegaApiClient.Tests/Extensions.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Linq.Expressions;
+using NUnit.Framework;
+using NUnit.Framework.Constraints;
+
+namespace CG.Web.MegaApiClient.Tests
+{
+    public static class Extensions
+    {
+        public static void DoIt(this Has has)
+        {
+            
+        }
+        // http://blog.drorhelper.com/2012/11/making-string-based-method-strongly.html?m=1
+        public static ResolvableConstraintExpression Property<T>(this ConstraintExpression expression, Expression<Func<T, object>> lambda)
+        {
+            MemberExpression memberExpression = null;
+            switch (lambda.Body.NodeType)
+            {
+                case ExpressionType.Convert:
+                    // lambda is obj => Convert(obj.Prop) - the operand of conversion is our member expression
+                    var unary = lambda.Body as UnaryExpression;
+                    if (unary == null)
+                    {
+                        Assert.Fail("Cannot parse expression");
+                    }
+                    memberExpression = unary.Operand as MemberExpression;
+                    break;
+
+                case ExpressionType.MemberAccess:
+                    // lambda is (obj => obj.Prop) - the body is the member expression
+                    memberExpression = lambda.Body as MemberExpression;
+                    break;
+
+                default:
+                    Assert.Fail("Cannot parse expression");
+                    break;
+            }
+
+            if (memberExpression == null || string.IsNullOrEmpty(memberExpression.Member.Name))
+            {
+                Assert.Fail("Labda body is not MemberExpression - use only properties");
+            }
+
+            var propertyName = memberExpression.Member.Name;
+
+            return expression.Property(propertyName);
+        }
+    }
+}

MegaApiClient.Tests/Login.cs

@@ -1,6 +1,11 @@
 
 
 using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Moq;
+using Newtonsoft.Json;
 using NUnit.Framework;
 
 namespace CG.Web.MegaApiClient.Tests
@@ -13,45 +18,52 @@ public Login()
         {
         }
 
-        [TestCase(null, null)]
-        [TestCase(null, "")]
-        [TestCase("", null)]
-        [TestCase("", "")]
-        [TestCase(null, "password")]
-        [TestCase("username", null)]
-        public void Login_UnsupportedCredentials_Throws(string username, string password)
+        [Test]
+        public void ClientCtor_NullWebClient_Throws()
+        {
+            Assert.That(
+                () => this.Client = new MegaApiClient(null),
+                Throws.TypeOf<ArgumentNullException>()
+                .With.Property<ArgumentNullException>(x => x.ParamName).EqualTo("webClient"));
+        }
+
+        [TestCaseSource("GetInvalidCredentials")]
+        public void Login_UnsupportedCredentials_Throws(string email, string password)
         {
             Assert.That(
-                () => this.Client.Login(username, password),
-                Throws.TypeOf<ArgumentNullException>());
+                () => this.Client.Login(email, password),
+                Throws.TypeOf<ArgumentNullException>()
+                .With.Property<ArgumentNullException>(x => x.ParamName).EqualTo("email")
+                .Or.With.Property<ArgumentNullException>(x => x.ParamName).EqualTo("password"));
         }
 
         [TestCase("username", "password", ApiResultCode.BadArguments)]
         [TestCase("[email protected]", "password", ApiResultCode.ResourceNotExists)]
-        public void Login_InvalidCredentials_Throws(string username, string password, ApiResultCode expectedErrorCode)
+        public void Login_InvalidCredentials_Throws(string email, string password, ApiResultCode expectedErrorCode)
         {
             Assert.That(
-                () => this.Client.Login(username, password),
+                () => this.Client.Login(email, password),
                 Throws.TypeOf<ApiException>()
-                .With.Property("ApiResultCode").EqualTo(expectedErrorCode));
+                .With.Property<ApiException>(x => x.ApiResultCode).EqualTo(expectedErrorCode));
         }
 
         [TestCaseSource("GetCredentials")]
-        public void Login_ValidCredentials_Succeeds(string username, string password)
+        public void Login_ValidCredentials_Succeeds(string email, string password)
         {
             Assert.That(
-                () => this.Client.Login(username, password),
+                () => this.Client.Login(email, password),
                 Throws.Nothing);
         }
 
         [TestCaseSource("GetCredentials")]
-        public void LoginTwice_ValidCredentials_Throws(string username, string password)
+        public void LoginTwice_ValidCredentials_Throws(string email, string password)
         {
-            this.Client.Login(username, password);
+            this.Client.Login(email, password);
 
             Assert.That(
-                () => this.Client.Login(username, password),
-                Throws.TypeOf<NotSupportedException>());
+                () => this.Client.Login(email, password),
+                Throws.TypeOf<NotSupportedException>()
+                .With.Message.EqualTo("Already logged in"));
         }
 
         [Test]
@@ -69,25 +81,129 @@ public void LoginAnonymousTwice_Throws()
 
             Assert.That(
                 () => this.Client.LoginAnonymous(),
-                Throws.TypeOf<NotSupportedException>());
+                Throws.TypeOf<NotSupportedException>()
+                .With.Message.EqualTo("Already logged in"));
         }
 
         [TestCaseSource("GetCredentials")]
-        public void LogoutAfterLogin_Succeeds(string username, string password)
+        public void LogoutAfterLogin_Succeeds(string email, string password)
         {
-            this.Client.Login(username, password);
-            
+            this.Client.Login(email, password);
+
             Assert.That(
                 () => this.Client.Logout(),
                 Throws.Nothing);
         }
 
+        [TestCaseSource("GetCredentials")]
+        public void LogoutTwiceAfterLogin_Throws(string email, string password)
+        {
+            this.Client.Login(email, password);
+
+            this.Client.Logout();
+
+            Assert.That(
+                () => this.Client.Logout(),
+                Throws.TypeOf<NotSupportedException>()
+                .With.Message.EqualTo("Not logged in"));
+        }
+
         [Test]
         public void LogoutWithoutLogin_Throws()
         {
             Assert.That(
                 () => this.Client.Logout(),
-                Throws.TypeOf<NotSupportedException>());
+                Throws.TypeOf<NotSupportedException>()
+                .With.Message.EqualTo("Not logged in"));
+        }
+
+        [TestCase(null)]
+        public void Login_NullAuthInfos_Throws(MegaApiClient.AuthInfos authInfos)
+        {
+            Assert.That(
+                () => this.Client.Login(authInfos),
+                Throws.TypeOf<ArgumentNullException>()
+                .With.Property<ArgumentNullException>(x => x.ParamName).EqualTo("authInfos"));
+        }
+
+        [TestCaseSource("GetCredentials")]
+        public void Login_DeserializedAuthInfos_Succeeds(string email, string password)
+        {
+            var authInfos = MegaApiClient.GenerateAuthInfos(email, password);
+            var serializedAuthInfos = JsonConvert.SerializeObject(authInfos, Formatting.None).Replace('\"', '\'');
+            var deserializedAuthInfos = JsonConvert.DeserializeObject<MegaApiClient.AuthInfos>(serializedAuthInfos);
+
+            Assert.That(
+                () => this.Client.Login(deserializedAuthInfos),
+                Throws.Nothing);
+        }
+
+        [TestCaseSource("GetInvalidCredentials")]
+        public void GenerateAuthInfos_InvalidCredentials_Throws(string email, string password)
+        {
+            Assert.That(() =>
+                MegaApiClient.GenerateAuthInfos(email, password),
+                Throws.TypeOf<ArgumentNullException>()
+                .With.Property<ArgumentNullException>(x => x.ParamName).EqualTo("email")
+                .Or.With.Property<ArgumentNullException>(x => x.ParamName).EqualTo("password"));
+        }
+
+        [TestCase("[email protected]", "password", Result = "{'Email':'[email protected]','Hash':'ObELy57HULI','PasswordAesKey':'ZAM5cl5uvROiXwBSEp98sQ=='}")]
+        public string GenerateAuthInfos_ValidCredentials_Succeeds(string email, string password)
+        {
+            var authInfos = MegaApiClient.GenerateAuthInfos(email, password);
+
+            return JsonConvert.SerializeObject(authInfos, Formatting.None).Replace('\"', '\'');
+        }
+
+        [TestCaseSource("GetMethodsRequiredLogin")]
+        public void Methods_LoginRequired_Throws(Action<MegaApiClient> testMethod)
+        {
+            Assert.That(
+                () => testMethod(this.Client),
+                Throws.TypeOf<NotSupportedException>()
+                .With.Message.EqualTo("Not logged in"));
+        }
+
+        private IEnumerable<ITestCaseData> GetInvalidCredentials()
+        {
+            yield return new TestCaseData(null, null);
+            yield return new TestCaseData(null, "");
+            yield return new TestCaseData("", null);
+            yield return new TestCaseData("", "");
+            yield return new TestCaseData(null, "password");
+            yield return new TestCaseData("username", null);
+        }
+
+        private IEnumerable<ITestCaseData> GetMethodsRequiredLogin()
+        {
+            Mock<INode> nodeDirectoryMock = new Mock<INode>();
+            nodeDirectoryMock.SetupGet(x => x.Type).Returns(NodeType.Directory);
+            nodeDirectoryMock.As<INodeCrypto>();
+            INode nodeDirectory = nodeDirectoryMock.Object;
+
+            Mock<INode> nodeFileMock = new Mock<INode>();
+            nodeFileMock.SetupGet(x => x.Type).Returns(NodeType.File);
+            nodeFileMock.As<INodeCrypto>();
+            INode nodeFile = nodeFileMock.Object;
+
+            Uri uri = new Uri("http://www.example.com");
+            string tempFile = Path.GetTempFileName();
+
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.Delete(nodeDirectory)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.Delete(nodeDirectory, false)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.Delete(nodeDirectory, true)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.DownloadFile(nodeFile, "outputFile")));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.DownloadFile(uri, "outputFile")));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.GetNodes()));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.GetNodes(nodeDirectory)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.CreateFolder("name", nodeDirectory)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.Download(nodeFile)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.Download(uri)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.GetDownloadLink(nodeDirectory)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.Move(nodeDirectory, nodeDirectory)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.Upload(new MemoryStream(new byte[0]), "name", nodeDirectory)));
+            yield return new TestCaseData((Action<MegaApiClient>)(x => x.Upload(tempFile, nodeDirectory)));
         }
     }
 }

MegaApiClient.Tests/MegaApiClient.Tests.csproj

@@ -37,12 +37,13 @@
     <AssemblyOriginatorKeyFile>..\key.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Castle.Core">
-      <HintPath>..\packages\Castle.Core.3.1.0\lib\net35\Castle.Core.dll</HintPath>
-    </Reference>
     <Reference Include="Moq">
       <HintPath>..\packages\Moq.4.2.1409.1722\lib\net35\Moq.dll</HintPath>
     </Reference>
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\net35\Newtonsoft.Json.dll</HintPath>
+    </Reference>
     <Reference Include="nunit.framework">
       <HintPath>..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
     </Reference>
@@ -53,7 +54,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Login.cs" />
+    <Compile Include="NodeOperations.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Extensions.cs" />
     <Compile Include="TestsBase.cs" />
     <Compile Include="Upload.cs" />
   </ItemGroup>