Skip to content

Commit cc1215d

Browse files
reeshika-hreeshika-h
committed
refactor: update exception handling in model tests to use ArgumentException
1 parent 673b7c7 commit cc1215d

14 files changed

Lines changed: 111 additions & 124 deletions

File tree

‎Contentstack.Management.Core.Unit.Tests/Contentstack.Management.Core.Unit.Tests.csproj‎

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -60,19 +60,13 @@
6060

6161
<Compile Remove="Models\AuditLogTest.cs" />
6262
<Compile Remove="Models\BaseModelTest.cs" />
63-
<Compile Remove="Models\DeliveryTokenTest.cs" />
6463
<Compile Remove="Models\ExtensionTest.cs" />
6564
<Compile Remove="Models\ExtensionModelTest.cs" />
6665
<Compile Remove="Models\LabelTest.cs" />
6766
<Compile Remove="Models\PublishQueueTest.cs" />
68-
<Compile Remove="Models\PublishRuleTest.cs" />
6967
<Compile Remove="Models\ReleaseTest.cs" />
7068
<Compile Remove="Models\ReleaseItemTest.cs" />
7169
<Compile Remove="Models\RoleTest.cs" />
72-
<Compile Remove="Models\TaxonomyTest.cs" />
73-
<Compile Remove="Models\TermTest.cs" />
74-
<Compile Remove="Models\WebhookTest.cs" />
75-
<Compile Remove="Models\WorkflowTest.cs" />
7670
<Compile Remove="Models\CustomExtensionTest.cs" />
7771

7872
<!-- Bulk Operations excluded from migration scope -->
@@ -83,7 +77,6 @@
8377
<Compile Remove="Core\Services\Stack\BulkReleaseItemsServiceTest.cs" />
8478
<Compile Remove="Core\Services\Stack\BulkUnpublishServiceTest.cs" />
8579
<Compile Remove="Core\Services\Stack\BulkUpdateItemsServiceTest.cs" />
86-
<Compile Remove="Core\Services\Stack\BulkWorkflowUpdateServiceTest.cs" />
8780
<Compile Remove="Services\BulkOperationServicesTest.cs" />
8881

8982
<!-- OAuth tests (out of scope) -->

‎Contentstack.Management.Core.Unit.Tests/Models/DeliveryTokenTest.cs‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -32,12 +32,12 @@ public void Initialize_DeliveryToken()
3232
DeliveryToken token = new DeliveryToken(_stack);
3333
Assert.IsNull(token.Uid);
3434
Assert.AreEqual("stacks/delivery_tokens", token.resourcePath);
35-
Assert.ThrowsException<InvalidOperationException>(() => token.Fetch());
36-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => token.FetchAsync());
37-
Assert.ThrowsException<InvalidOperationException>(() => token.Update(_fixture.Create<DeliveryTokenModel>()));
38-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => token.UpdateAsync(_fixture.Create<DeliveryTokenModel>()));
39-
Assert.ThrowsException<InvalidOperationException>(() => token.Delete());
40-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => token.DeleteAsync());
35+
Assert.ThrowsException<ArgumentException>(() => token.Fetch());
36+
Assert.ThrowsExceptionAsync<ArgumentException>(() => token.FetchAsync());
37+
Assert.ThrowsException<ArgumentException>(() => token.Update(_fixture.Create<DeliveryTokenModel>()));
38+
Assert.ThrowsExceptionAsync<ArgumentException>(() => token.UpdateAsync(_fixture.Create<DeliveryTokenModel>()));
39+
Assert.ThrowsException<ArgumentException>(() => token.Delete());
40+
Assert.ThrowsExceptionAsync<ArgumentException>(() => token.DeleteAsync());
4141
Assert.AreEqual(token.Query().GetType(), typeof(Query));
4242
}
4343

‎Contentstack.Management.Core.Unit.Tests/Models/PublishRuleTest.cs‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -29,12 +29,12 @@ public void Initialize_PublishRule()
2929

3030
Assert.IsNull(publishRule.Uid);
3131
Assert.AreEqual($"/workflows/publishing_rules", publishRule.resourcePath);
32-
Assert.ThrowsException<InvalidOperationException>(() => publishRule.Fetch());
33-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => publishRule.FetchAsync());
34-
Assert.ThrowsException<InvalidOperationException>(() => publishRule.Update(_fixture.Create<PublishRuleModel>()));
35-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => publishRule.UpdateAsync(_fixture.Create<PublishRuleModel>()));
36-
Assert.ThrowsException<InvalidOperationException>(() => publishRule.Delete());
37-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => publishRule.DeleteAsync());
32+
Assert.ThrowsException<ArgumentException>(() => publishRule.Fetch());
33+
Assert.ThrowsExceptionAsync<ArgumentException>(() => publishRule.FetchAsync());
34+
Assert.ThrowsException<ArgumentException>(() => publishRule.Update(_fixture.Create<PublishRuleModel>()));
35+
Assert.ThrowsExceptionAsync<ArgumentException>(() => publishRule.UpdateAsync(_fixture.Create<PublishRuleModel>()));
36+
Assert.ThrowsException<ArgumentException>(() => publishRule.Delete());
37+
Assert.ThrowsExceptionAsync<ArgumentException>(() => publishRule.DeleteAsync());
3838
}
3939

4040
[TestMethod]
@@ -57,7 +57,7 @@ public void Should_Create_PublishRule()
5757
ContentstackResponse response = _stack.Workflow().PublishRule().Create(new PublishRuleModel());
5858

5959
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
60-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
60+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
6161
}
6262

6363
[TestMethod]
@@ -66,7 +66,7 @@ public async System.Threading.Tasks.Task Should_Create_PublishRule_Async()
6666
ContentstackResponse response = await _stack.Workflow().PublishRule().CreateAsync(new PublishRuleModel());
6767

6868
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
69-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
69+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
7070
}
7171

7272
[TestMethod]
@@ -75,7 +75,7 @@ public void Should_Find_All_PublishRule()
7575
ContentstackResponse response = _stack.Workflow().PublishRule().FindAll();
7676

7777
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
78-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
78+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
7979
}
8080

8181
[TestMethod]
@@ -84,7 +84,7 @@ public async System.Threading.Tasks.Task Should_Find_All_PublishRule_Async()
8484
ContentstackResponse response = await _stack.Workflow().PublishRule().FindAllAsync();
8585

8686
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
87-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
87+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
8888
}
8989

9090
[TestMethod]
@@ -93,7 +93,7 @@ public void Should_Fetch_PublishRule()
9393
ContentstackResponse response = _stack.Workflow().PublishRule(_fixture.Create<string>()).Fetch();
9494

9595
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
96-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
96+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
9797
}
9898

9999
[TestMethod]
@@ -102,7 +102,7 @@ public async System.Threading.Tasks.Task Should_Find_PublishRule_Async()
102102
ContentstackResponse response = await _stack.Workflow().PublishRule(_fixture.Create<string>()).FetchAsync();
103103

104104
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
105-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
105+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
106106
}
107107

108108
[TestMethod]
@@ -111,7 +111,7 @@ public void Should_Update_PublishRule()
111111
ContentstackResponse response = _stack.Workflow().PublishRule(_fixture.Create<string>()).Update(new PublishRuleModel());
112112

113113
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
114-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
114+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
115115
}
116116

117117
[TestMethod]
@@ -120,7 +120,7 @@ public async System.Threading.Tasks.Task Should_Update_PublishRule_Async()
120120
ContentstackResponse response = await _stack.Workflow().PublishRule(_fixture.Create<string>()).UpdateAsync(new PublishRuleModel());
121121

122122
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
123-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
123+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
124124
}
125125

126126
[TestMethod]
@@ -129,7 +129,7 @@ public void Should_Delete_PublishRule()
129129
ContentstackResponse response = _stack.Workflow().PublishRule(_fixture.Create<string>()).Delete();
130130

131131
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
132-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
132+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
133133
}
134134

135135
[TestMethod]
@@ -138,7 +138,7 @@ public async System.Threading.Tasks.Task Should_Delete_PublishRule_Async()
138138
ContentstackResponse response = await _stack.Workflow().PublishRule(_fixture.Create<string>()).DeleteAsync();
139139

140140
Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
141-
Assert.AreEqual(_contentstackResponse.OpenJObjectResponse().ToString(), response.OpenJObjectResponse().ToString());
141+
Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
142142
}
143143
}
144144
}

‎Contentstack.Management.Core.Unit.Tests/Models/TaxonomyTest.cs‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -33,13 +33,13 @@ public void Initialize_Taxonomy()
3333

3434
Assert.IsNull(taxonomy.Uid);
3535
Assert.AreEqual("/taxonomies", taxonomy.resourcePath);
36-
Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Fetch());
37-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => taxonomy.FetchAsync());
38-
Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Update(_fixture.Create<TaxonomyModel>()));
39-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => taxonomy.UpdateAsync(_fixture.Create<TaxonomyModel>()));
40-
Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Delete());
41-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => taxonomy.DeleteAsync());
42-
Assert.ThrowsException<InvalidOperationException>(() => taxonomy.Terms());
36+
Assert.ThrowsException<ArgumentException>(() => taxonomy.Fetch());
37+
Assert.ThrowsExceptionAsync<ArgumentException>(() => taxonomy.FetchAsync());
38+
Assert.ThrowsException<ArgumentException>(() => taxonomy.Update(_fixture.Create<TaxonomyModel>()));
39+
Assert.ThrowsExceptionAsync<ArgumentException>(() => taxonomy.UpdateAsync(_fixture.Create<TaxonomyModel>()));
40+
Assert.ThrowsException<ArgumentException>(() => taxonomy.Delete());
41+
Assert.ThrowsExceptionAsync<ArgumentException>(() => taxonomy.DeleteAsync());
42+
Assert.ThrowsException<ArgumentException>(() => taxonomy.Terms());
4343
Assert.AreEqual(typeof(Query), taxonomy.Query().GetType());
4444
}
4545

@@ -136,22 +136,22 @@ public void Should_Get_Single_Term_From_Taxonomy()
136136
[TestMethod]
137137
public void Export_Throws_When_Uid_Is_Empty()
138138
{
139-
Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy().Export());
140-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy().ExportAsync());
139+
Assert.ThrowsException<ArgumentException>(() => _stack.Taxonomy().Export());
140+
Assert.ThrowsExceptionAsync<ArgumentException>(() => _stack.Taxonomy().ExportAsync());
141141
}
142142

143143
[TestMethod]
144144
public void Locales_Throws_When_Uid_Is_Empty()
145145
{
146-
Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy().Locales());
147-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy().LocalesAsync());
146+
Assert.ThrowsException<ArgumentException>(() => _stack.Taxonomy().Locales());
147+
Assert.ThrowsExceptionAsync<ArgumentException>(() => _stack.Taxonomy().LocalesAsync());
148148
}
149149

150150
[TestMethod]
151151
public void Localize_Throws_When_Uid_Is_Empty()
152152
{
153-
Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy().Localize(_fixture.Create<TaxonomyModel>()));
154-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy().LocalizeAsync(_fixture.Create<TaxonomyModel>()));
153+
Assert.ThrowsException<ArgumentException>(() => _stack.Taxonomy().Localize(_fixture.Create<TaxonomyModel>()));
154+
Assert.ThrowsExceptionAsync<ArgumentException>(() => _stack.Taxonomy().LocalizeAsync(_fixture.Create<TaxonomyModel>()));
155155
}
156156

157157
[TestMethod]

‎Contentstack.Management.Core.Unit.Tests/Models/TermTest.cs‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -32,8 +32,8 @@ public void Initialize_Term_Collection()
3232

3333
Assert.IsNull(term.Uid);
3434
Assert.AreEqual($"/taxonomies/{taxonomyUid}/terms", term.resourcePath);
35-
Assert.ThrowsException<InvalidOperationException>(() => term.Fetch());
36-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => term.FetchAsync());
35+
Assert.ThrowsException<ArgumentException>(() => term.Fetch());
36+
Assert.ThrowsExceptionAsync<ArgumentException>(() => term.FetchAsync());
3737
Assert.AreEqual(typeof(Query), term.Query().GetType());
3838
}
3939

@@ -139,40 +139,40 @@ public async System.Threading.Tasks.Task Should_Search_Terms_Async()
139139
public void Ancestors_Throws_When_Term_Uid_Is_Empty()
140140
{
141141
string taxonomyUid = _fixture.Create<string>();
142-
Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().Ancestors());
143-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().AncestorsAsync());
142+
Assert.ThrowsException<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().Ancestors());
143+
Assert.ThrowsExceptionAsync<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().AncestorsAsync());
144144
}
145145

146146
[TestMethod]
147147
public void Descendants_Throws_When_Term_Uid_Is_Empty()
148148
{
149149
string taxonomyUid = _fixture.Create<string>();
150-
Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().Descendants());
151-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().DescendantsAsync());
150+
Assert.ThrowsException<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().Descendants());
151+
Assert.ThrowsExceptionAsync<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().DescendantsAsync());
152152
}
153153

154154
[TestMethod]
155155
public void Move_Throws_When_Term_Uid_Is_Empty()
156156
{
157157
string taxonomyUid = _fixture.Create<string>();
158-
Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().Move(_fixture.Create<TermMoveModel>()));
159-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().MoveAsync(_fixture.Create<TermMoveModel>()));
158+
Assert.ThrowsException<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().Move(_fixture.Create<TermMoveModel>()));
159+
Assert.ThrowsExceptionAsync<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().MoveAsync(_fixture.Create<TermMoveModel>()));
160160
}
161161

162162
[TestMethod]
163163
public void Locales_Throws_When_Term_Uid_Is_Empty()
164164
{
165165
string taxonomyUid = _fixture.Create<string>();
166-
Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().Locales());
167-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().LocalesAsync());
166+
Assert.ThrowsException<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().Locales());
167+
Assert.ThrowsExceptionAsync<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().LocalesAsync());
168168
}
169169

170170
[TestMethod]
171171
public void Localize_Throws_When_Term_Uid_Is_Empty()
172172
{
173173
string taxonomyUid = _fixture.Create<string>();
174-
Assert.ThrowsException<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().Localize(_fixture.Create<TermModel>()));
175-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => _stack.Taxonomy(taxonomyUid).Terms().LocalizeAsync(_fixture.Create<TermModel>()));
174+
Assert.ThrowsException<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().Localize(_fixture.Create<TermModel>()));
175+
Assert.ThrowsExceptionAsync<ArgumentException>(() => _stack.Taxonomy(taxonomyUid).Terms().LocalizeAsync(_fixture.Create<TermModel>()));
176176
}
177177
}
178178
}

‎Contentstack.Management.Core.Unit.Tests/Models/WebhookTest.cs‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -30,18 +30,18 @@ public void Initialize_Webhook()
3030

3131
Assert.IsNull(webhook.Uid);
3232
Assert.AreEqual($"/webhooks", webhook.resourcePath);
33-
Assert.ThrowsException<InvalidOperationException>(() => webhook.Fetch());
34-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => webhook.FetchAsync());
35-
Assert.ThrowsException<InvalidOperationException>(() => webhook.Update(_fixture.Create<WebhookModel>()));
36-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => webhook.UpdateAsync(_fixture.Create<WebhookModel>()));
37-
Assert.ThrowsException<InvalidOperationException>(() => webhook.Delete());
38-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => webhook.DeleteAsync());
39-
Assert.ThrowsException<InvalidOperationException>(() => webhook.Executions());
40-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => webhook.ExecutionsAsync());
41-
Assert.ThrowsException<InvalidOperationException>(() => webhook.Retry(_fixture.Create<string>()));
42-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => webhook.RetryAsync(_fixture.Create<string>()));
43-
Assert.ThrowsException<InvalidOperationException>(() => webhook.Logs(_fixture.Create<string>()));
44-
Assert.ThrowsExceptionAsync<InvalidOperationException>(() => webhook.LogsAsync(_fixture.Create<string>()));
33+
Assert.ThrowsException<ArgumentException>(() => webhook.Fetch());
34+
Assert.ThrowsExceptionAsync<ArgumentException>(() => webhook.FetchAsync());
35+
Assert.ThrowsException<ArgumentException>(() => webhook.Update(_fixture.Create<WebhookModel>()));
36+
Assert.ThrowsExceptionAsync<ArgumentException>(() => webhook.UpdateAsync(_fixture.Create<WebhookModel>()));
37+
Assert.ThrowsException<ArgumentException>(() => webhook.Delete());
38+
Assert.ThrowsExceptionAsync<ArgumentException>(() => webhook.DeleteAsync());
39+
Assert.ThrowsException<ArgumentException>(() => webhook.Executions());
40+
Assert.ThrowsExceptionAsync<ArgumentException>(() => webhook.ExecutionsAsync());
41+
Assert.ThrowsException<ArgumentException>(() => webhook.Retry(_fixture.Create<string>()));
42+
Assert.ThrowsExceptionAsync<ArgumentException>(() => webhook.RetryAsync(_fixture.Create<string>()));
43+
Assert.ThrowsException<ArgumentException>(() => webhook.Logs(_fixture.Create<string>()));
44+
Assert.ThrowsExceptionAsync<ArgumentException>(() => webhook.LogsAsync(_fixture.Create<string>()));
4545
Assert.AreEqual(webhook.Query().GetType(), typeof(Query));
4646
}
4747

0 commit comments

Comments
 (0)