contentstack-management-dotnet/Contentstack.Management.Core.Unit.Tests/Models/BaseModelTest.cs at 93aefe52564fde475a93b4f61029ad8c207acacb · contentstack/contentstack-management-dotnet · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
using System;
using AutoFixture;
using Contentstack.Management.Core.Models;
using Contentstack.Management.Core.Unit.Tests.Mokes;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Contentstack.Management.Core.Unit.Tests.Models
{
    [TestClass]
    public class BaseModelTest
    {
        private Stack _stack;
        private readonly IFixture _fixture = new Fixture();
        private ContentstackResponse _contentstackResponse;
        [TestInitialize]
        public void initialize()
        {
            ContentstackClient client = new ContentstackClient();

            _contentstackResponse = MockResponse.CreateContentstackResponse("MockResponse.txt");
            client.ContentstackPipeline.ReplaceHandler(new MockHttpHandler(_contentstackResponse));
            client.contentstackOptions.Authtoken = _fixture.Create<string>();

            _stack = new Stack(client, _fixture.Create<string>());
        }

        [TestMethod]
        public void Should_Throw_on_API_Key_Empty()
        {
            Assert.ThrowsException<InvalidOperationException>(() => new BaseModel<ContentModelling>(new Stack(null), _fixture.Create<string>()));
        }

        [TestMethod]
        public void Should_Throw_on_FieldName_Empty()
        {
            Assert.ThrowsException<ArgumentNullException>(() => new BaseModel<ContentModelling>(_stack, null));
        }

        [TestMethod]
        public void Initialize_ContentType()
        {
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>());

            Assert.IsNull(baseModel.Uid);
            Assert.ThrowsException<ArgumentException>(() => baseModel.Fetch());
            Assert.ThrowsExceptionAsync<ArgumentException>(() => baseModel.FetchAsync());
            Assert.ThrowsException<ArgumentException>(() => baseModel.Update(new ContentModelling()));
            Assert.ThrowsExceptionAsync<ArgumentException>(() => baseModel.UpdateAsync(new ContentModelling()));
            Assert.ThrowsException<ArgumentException>(() => baseModel.Delete());
            Assert.ThrowsExceptionAsync<ArgumentException>(() => baseModel.DeleteAsync());

        }
        [TestMethod]
        public void Initialize_BaseModel_With_Uid()
        {
            string uid = _fixture.Create<string>();
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>(), uid);

            Assert.AreEqual(uid, baseModel.Uid);
            Assert.ThrowsException<InvalidOperationException>(() => baseModel.Create(new ContentModelling()));
            Assert.ThrowsExceptionAsync<InvalidOperationException>(() => baseModel.CreateAsync(new ContentModelling()));
        }

        [TestMethod]
        public void Should_Return_Mock_Response_On_Create()
        {
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>());
            baseModel.resourcePath = "/Path";

            ContentstackResponse response = baseModel.Create(new ContentModelling());

            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
        }

        [TestMethod]
        public async System.Threading.Tasks.Task Should_Return_Mock_Response_On_CreateAsync()
        {
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>());
            baseModel.resourcePath = "/Path";

            ContentstackResponse response = await baseModel.CreateAsync(new ContentModelling());

            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
        }

        [TestMethod]
        public void Should_Return_Mock_Response_On_Update()
        {
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>(), _fixture.Create<string>());
            baseModel.resourcePath = "/Path";

            ContentstackResponse response = baseModel.Update(new ContentModelling());

            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
        }

        [TestMethod]
        public async System.Threading.Tasks.Task Should_Return_Mock_Response_On_UpdateAsync()
        {
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>(), _fixture.Create<string>());
            baseModel.resourcePath = "/Path";

            ContentstackResponse response = await baseModel.UpdateAsync(new ContentModelling());

            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
        }

        [TestMethod]
        public void Should_Return_Mock_Response_On_Fetch()
        {
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>(), _fixture.Create<string>());
            baseModel.resourcePath = "/Path";

            ContentstackResponse response = baseModel.Fetch();

            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
        }

        [TestMethod]
        public async System.Threading.Tasks.Task Should_Return_Mock_Response_On_FetchAsync()
        {
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>(), _fixture.Create<string>());
            baseModel.resourcePath = "/Path";

            ContentstackResponse response = await baseModel.FetchAsync();

            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
        }

        [TestMethod]
        public void Should_Return_Mock_Response_On_Delete()
        {
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>(), _fixture.Create<string>());
            baseModel.resourcePath = "/Path";

            ContentstackResponse response = baseModel.Delete();

            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
        }

        [TestMethod]
        public async System.Threading.Tasks.Task Should_Return_Mock_Response_On_DeleteAsync()
        {
            BaseModel<ContentModelling> baseModel = new BaseModel<ContentModelling>(_stack, _fixture.Create<string>(), _fixture.Create<string>());
            baseModel.resourcePath = "/Path";

            ContentstackResponse response = await baseModel.DeleteAsync();

            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
        }
    }
}