Datei: IntegrationTests/IntegrationTests/IntermediateClassTest.cs

Last Commit (9d1552b)
1 //
2 // Copyright (c) 2002-2016 Mirko Matytschak
3 // (www.netdataobjects.de)
4 //
5 // Author: Mirko Matytschak
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8 // documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10 // Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11 // conditions:
12
13 // The above copyright notice and this permission notice shall be included in all copies or substantial portions
14 // of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19 // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 // DEALINGS IN THE SOFTWARE.
21
22
23 using System;
24 using System.Linq;
25 using System.Data.Common;
26 using System.Diagnostics;
27 using System.Collections;
28 using NUnit.Framework;
29 using NDO;
30 using NDO.Mapping;
31 using NDOInterfaces;
32 using PureBusinessClasses;
33 using NDO.Query;
 
 
34
35 namespace NdoUnitTests
36 {
37 ····[TestFixture]
38 public class IntermediateClassTest
39 ····{
40 ········Order order;
41 ········Product pr;
42 ········
43 ········[SetUp]
44 ········public void Setup()
45 ········{
46 ········}
47
48 ········void CreateProductAndOrder(PersistenceManager pm)
49 ········{
50 ············order = new Order();
51 ············order.Date = DateTime.Now;
52 ············pm.MakePersistent( order );
53
54 ············pr = new Product();
55 ············pr.Name = "Shirt";
56 ············pm.MakePersistent( pr );
57 ············pm.Save();
58 ········}
59
60 ········[TearDown]
61 ········public void TearDown()
62 ········{
63 ············var pm = PmFactory.NewPersistenceManager();
64 ············pm.Delete(pm.GetClassExtent(typeof(Order)));
65 ············pm.Save();
66 ············pm.Delete(pm.GetClassExtent(typeof(Product)));
67 ············pm.Save();
68 ········}
69
70 ········private void CreateOrderDetail()
71 ········{
72 ············OrderDetail od = order.NewOrderDetail(pr);
73 ············od.Price =49m;
74 ············Assert.That(od.NDOObjectId.Id is DependentKey, "Wrong type");
75 ············DependentKey dk = (DependentKey) od.NDOObjectId.Id;
76 ············Assert.That(dk.IsValid, "Dependent key not valid");
77 ········}
78
79 ········[Test]
80 ········public void TestCreateSave()
81 ········{
82 ············var pm = PmFactory.NewPersistenceManager();
83 ············CreateSave( pm );
84 ········}
85
86 ········public void CreateSave(PersistenceManager pm)
87 ········{
88 ············CreateProductAndOrder( pm );
89 var logAdapter = new TestLogAdapter( ) ;
90 ············pm.VerboseMode = true;
91 ············pm.LogAdapter = logAdapter;
92 ············CreateOrderDetail();
93 ············pm.Save();
94 ············pm.UnloadCache();
95 ············IList orders = pm.GetClassExtent(typeof(Order));
96 ············Assert.That(1 ==··orders.Count );
97 ············Order o = (Order) orders[0];
98 ············Assert.That(1 ==··o.OrderDetails.Count() );
99 var text = logAdapter. Text;
100 ············OrderDetail od = (OrderDetail) o.OrderDetails.First();
101 ············Assert.That(od.Product != null, "Product shouldn't be null");
102 ········}
103
104 ········[Test]
105 ········public void WrongSetup()
106 ········{
107 ············var pm = PmFactory.NewPersistenceManager();
108 ············order = new Order();
109 ············order.Date = DateTime.Now.Date;
110 ············pm.MakePersistent(order);
111 ············int exnr = 0;
112 ············try
113 ············{
114 ················order.NewOrderDetail(null);
115 ············}
116 ············catch (NDOException ex)
117 ············{
118 ················exnr = ex.ErrorNumber;
119 ············}
120 ············Assert.That(exnr == 41, "NDOException #41 should have been happened");
121 ········}
122
123 ········[Test]
124 ········public void RemoveRelatedObject()
125 ········{
126 ············var pm = PmFactory.NewPersistenceManager();
127 ············CreateProductAndOrder( pm );
128 ············CreateOrderDetail();
129 ············OrderDetail od = (OrderDetail)order.OrderDetails.First();
130 ············Assert.That(NDOObjectState.Created ==··od.NDOObjectState );
131 ············order.RemoveOrderDetail( od );
132 ············Assert.That(NDOObjectState.Transient ==··od.NDOObjectState );
133 ········}
134
135 ········[Test]
136 ········public void RemoveRelatedObjectSave()
137 ········{
138 ············var pm = PmFactory.NewPersistenceManager();
139 ············CreateProductAndOrder( pm );
140 ············CreateOrderDetail();
141 ············OrderDetail od = (OrderDetail)order.OrderDetails.First();
142 ············Assert.That(od.NDOObjectState == NDOObjectState.Created, "Wrong state #1");
143 ············pm.Save();
144 ············Assert.That(od.NDOObjectState == NDOObjectState.Persistent, "Wrong state #2");
145 ············order.RemoveOrderDetail(od);
146 ············Assert.That(od.NDOObjectState == NDOObjectState.Deleted, "Wrong state #3");
147 ········}
148
149 ········[Test]
150 ········public void RemoveRelatedObjectSaveReload()
151 ········{
152 ············var pm = PmFactory.NewPersistenceManager();
153 ············CreateProductAndOrder( pm );
154 ············CreateOrderDetail();
155 ············OrderDetail od = (OrderDetail)order.OrderDetails.First();
156 ············Assert.That( od.NDOObjectState == NDOObjectState.Created, "Wrong state #1" );
157 ············pm.Save();
158 ············Assert.That( od.NDOObjectState == NDOObjectState.Persistent, "Wrong state #2" );
159 ············order.RemoveOrderDetail( od );
160 ············Assert.That( od.NDOObjectState == NDOObjectState.Deleted, "Wrong state #3" );
161 ············pm.Save();
162 ············pm.UnloadCache();
163 ············order = pm.Objects<Order>().Single();
164 ············Assert.That(0 ==··order.OrderDetails.Count() );
165 ············Assert.That(0 ==··pm.Objects<OrderDetail>().Count );
166
167 ········}
168
169 ········[Test]
170 ········public void InsertWithTransientOrder()
171 ········{
172 ············Order o2 = new Order();
173 ············o2.Date = DateTime.Now;
174 ············OrderDetail od = o2.NewOrderDetail(this.pr);
175 ············// Nothing should happen, since o2 is transient and is
176 ············// not under the control of the pm.
177 ········}
178
179
180 ········[Test]
181 ········public void InsertWithTransientProduct()
182 ········{
183 ············Product p2 = new Product();
184 ············p2.Name = "Trouser";
185 ············int exnr = 0;
186 ············try
187 ············{
188 ················OrderDetail od = order.NewOrderDetail(p2);
189 ············}
190 ············catch (NDOException ex)
191 ············{
192 ················exnr = ex.ErrorNumber;
193 ············}
194 ············Assert.That(exnr == 59, "Exception 59 should have been occured");
195 ········}
196
197
198 ········[Test]
199 ········public void Insert()
200 ········{
201 ············var pm = PmFactory.NewPersistenceManager();
202 ············CreateSave(pm);
203 ············Product p2 = new Product();
204 ············p2.Name = "Trouser";
205 ············pm.MakePersistent(p2);
206 ············OrderDetail od = order.NewOrderDetail(p2);
207 ············Assert.That(NDOObjectState.Created ==··od.NDOObjectState, "Wrong state");
208 ············od.Price = 55;
209 ············pm.Save();
210 ············pm.UnloadCache();
211 ············IQuery q = new NDOQuery<Order>(pm);
212 ············order = (Order) q.ExecuteSingle(true);
213 ············Assert.That(2 ==··order.OrderDetails.Count(), "Wrong count");
214 ········}
215
216
217 ········[Test]
218 ········public void Reload()
219 ········{
220 ············var pm = PmFactory.NewPersistenceManager();
221 ············CreateSave(pm);
222 ············OrderDetail od = (OrderDetail) order.OrderDetails.First();
223 ············pm.UnloadCache();
224 ············od = (OrderDetail) pm.FindObject(od.NDOObjectId);
225 ············decimal d = od.Price;
226 ········}
227
228 ········[Test]
229 ········public void Delete()
230 ········{
231 ············var pm = PmFactory.NewPersistenceManager();
232 ············CreateSave( pm );
233 ············pm.UnloadCache();
234 ············var q = new NDOQuery<Order>(pm);
235 ············var order = q.ExecuteSingle(true);
236 ············order.RemoveOrderDetail( order.OrderDetails.First() );
237 ············pm.Save();
238 ············pm.UnloadCache();
239 ············var count = pm.Objects<OrderDetail>().Count;
240 ············Assert.That(0 ==··count );
241
242 ············order = pm.Objects<Order>().Single(); // Throws, if count != 1
243 ············Assert.That(0 ==··order.OrderDetails.Count() );
244 ········}
245
246 ········[Test]
247 ········public void DeleteParent()
248 ········{
249 ············var pm = PmFactory.NewPersistenceManager();
250 ············CreateSave(pm);
251 ············pm.UnloadCache();
252 ············IQuery q = new NDOQuery<Order>(pm);
253 ············order = (Order) q.ExecuteSingle(true);
254 ············pm.Delete(order);
255 ············pm.Save();
256 ············pm.UnloadCache();
257 ············IList l = pm.GetClassExtent(typeof(OrderDetail));
258 ············Assert.That(0 ==··l.Count, "Wrong count #1");
259 ············l = pm.GetClassExtent(typeof(Order));
260 ············Assert.That(0 ==··l.Count, "Wrong count #2");
261 ········}
262 ····}
263 }
264
New Commit (60cb179)
1 //
2 // Copyright (c) 2002-2016 Mirko Matytschak
3 // (www.netdataobjects.de)
4 //
5 // Author: Mirko Matytschak
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8 // documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10 // Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11 // conditions:
12
13 // The above copyright notice and this permission notice shall be included in all copies or substantial portions
14 // of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19 // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 // DEALINGS IN THE SOFTWARE.
21
22
23 using System;
24 using System.Linq;
 
 
25 using System.Collections;
26 using NUnit.Framework;
27 using NDO;
 
 
28 using PureBusinessClasses;
29 using NDO.Query;
30 using Microsoft.Extensions.DependencyInjection;
31 using Microsoft.Extensions.Logging;
32
33 namespace NdoUnitTests
34 {
35 ····[TestFixture]
36 public class IntermediateClassTest : NDOTest
37 ····{
38 ········Order order;
39 ········Product pr;
40 ········
41 ········[SetUp]
42 ········public void Setup()
43 ········{
44 ········}
45
46 ········void CreateProductAndOrder(PersistenceManager pm)
47 ········{
48 ············order = new Order();
49 ············order.Date = DateTime.Now;
50 ············pm.MakePersistent( order );
51
52 ············pr = new Product();
53 ············pr.Name = "Shirt";
54 ············pm.MakePersistent( pr );
55 ············pm.Save();
56 ········}
57
58 ········[TearDown]
59 ········public void TearDown()
60 ········{
61 ············var pm = PmFactory.NewPersistenceManager();
62 ············pm.Delete(pm.GetClassExtent(typeof(Order)));
63 ············pm.Save();
64 ············pm.Delete(pm.GetClassExtent(typeof(Product)));
65 ············pm.Save();
66 ········}
67
68 ········private void CreateOrderDetail()
69 ········{
70 ············OrderDetail od = order.NewOrderDetail(pr);
71 ············od.Price =49m;
72 ············Assert.That(od.NDOObjectId.Id is DependentKey, "Wrong type");
73 ············DependentKey dk = (DependentKey) od.NDOObjectId.Id;
74 ············Assert.That(dk.IsValid, "Dependent key not valid");
75 ········}
76
77 ········[Test]
78 ········public void TestCreateSave()
79 ········{
80 ············var pm = PmFactory.NewPersistenceManager();
81 ············CreateSave( pm );
82 ········}
83
84 ········public void CreateSave(PersistenceManager pm)
85 ········{
86 ············CreateProductAndOrder( pm );
87 var logger = ( TestLogger) Host. Services. GetRequiredService<ILoggerFactory>( ) . CreateLogger( "Tests") ;
 
 
88 ············CreateOrderDetail();
89 ············pm.Save();
90 ············pm.UnloadCache();
91 ············IList orders = pm.GetClassExtent(typeof(Order));
92 ············Assert.That(1 ==··orders.Count );
93 ············Order o = (Order) orders[0];
94 ············Assert.That(1 ==··o.OrderDetails.Count() );
95 var text = logger. Text;
96 ············OrderDetail od = (OrderDetail) o.OrderDetails.First();
97 ············Assert.That(od.Product != null, "Product shouldn't be null");
98 ········}
99
100 ········[Test]
101 ········public void WrongSetup()
102 ········{
103 ············var pm = PmFactory.NewPersistenceManager();
104 ············order = new Order();
105 ············order.Date = DateTime.Now.Date;
106 ············pm.MakePersistent(order);
107 ············int exnr = 0;
108 ············try
109 ············{
110 ················order.NewOrderDetail(null);
111 ············}
112 ············catch (NDOException ex)
113 ············{
114 ················exnr = ex.ErrorNumber;
115 ············}
116 ············Assert.That(exnr == 41, "NDOException #41 should have been happened");
117 ········}
118
119 ········[Test]
120 ········public void RemoveRelatedObject()
121 ········{
122 ············var pm = PmFactory.NewPersistenceManager();
123 ············CreateProductAndOrder( pm );
124 ············CreateOrderDetail();
125 ············OrderDetail od = (OrderDetail)order.OrderDetails.First();
126 ············Assert.That(NDOObjectState.Created ==··od.NDOObjectState );
127 ············order.RemoveOrderDetail( od );
128 ············Assert.That(NDOObjectState.Transient ==··od.NDOObjectState );
129 ········}
130
131 ········[Test]
132 ········public void RemoveRelatedObjectSave()
133 ········{
134 ············var pm = PmFactory.NewPersistenceManager();
135 ············CreateProductAndOrder( pm );
136 ············CreateOrderDetail();
137 ············OrderDetail od = (OrderDetail)order.OrderDetails.First();
138 ············Assert.That(od.NDOObjectState == NDOObjectState.Created, "Wrong state #1");
139 ············pm.Save();
140 ············Assert.That(od.NDOObjectState == NDOObjectState.Persistent, "Wrong state #2");
141 ············order.RemoveOrderDetail(od);
142 ············Assert.That(od.NDOObjectState == NDOObjectState.Deleted, "Wrong state #3");
143 ········}
144
145 ········[Test]
146 ········public void RemoveRelatedObjectSaveReload()
147 ········{
148 ············var pm = PmFactory.NewPersistenceManager();
149 ············CreateProductAndOrder( pm );
150 ············CreateOrderDetail();
151 ············OrderDetail od = (OrderDetail)order.OrderDetails.First();
152 ············Assert.That( od.NDOObjectState == NDOObjectState.Created, "Wrong state #1" );
153 ············pm.Save();
154 ············Assert.That( od.NDOObjectState == NDOObjectState.Persistent, "Wrong state #2" );
155 ············order.RemoveOrderDetail( od );
156 ············Assert.That( od.NDOObjectState == NDOObjectState.Deleted, "Wrong state #3" );
157 ············pm.Save();
158 ············pm.UnloadCache();
159 ············order = pm.Objects<Order>().Single();
160 ············Assert.That(0 ==··order.OrderDetails.Count() );
161 ············Assert.That(0 ==··pm.Objects<OrderDetail>().Count );
162
163 ········}
164
165 ········[Test]
166 ········public void InsertWithTransientOrder()
167 ········{
168 ············Order o2 = new Order();
169 ············o2.Date = DateTime.Now;
170 ············OrderDetail od = o2.NewOrderDetail(this.pr);
171 ············// Nothing should happen, since o2 is transient and is
172 ············// not under the control of the pm.
173 ········}
174
175
176 ········[Test]
177 ········public void InsertWithTransientProduct()
178 ········{
179 ············Product p2 = new Product();
180 ············p2.Name = "Trouser";
181 ············int exnr = 0;
182 ············try
183 ············{
184 ················OrderDetail od = order.NewOrderDetail(p2);
185 ············}
186 ············catch (NDOException ex)
187 ············{
188 ················exnr = ex.ErrorNumber;
189 ············}
190 ············Assert.That(exnr == 59, "Exception 59 should have been occured");
191 ········}
192
193
194 ········[Test]
195 ········public void Insert()
196 ········{
197 ············var pm = PmFactory.NewPersistenceManager();
198 ············CreateSave(pm);
199 ············Product p2 = new Product();
200 ············p2.Name = "Trouser";
201 ············pm.MakePersistent(p2);
202 ············OrderDetail od = order.NewOrderDetail(p2);
203 ············Assert.That(NDOObjectState.Created ==··od.NDOObjectState, "Wrong state");
204 ············od.Price = 55;
205 ············pm.Save();
206 ············pm.UnloadCache();
207 ············IQuery q = new NDOQuery<Order>(pm);
208 ············order = (Order) q.ExecuteSingle(true);
209 ············Assert.That(2 ==··order.OrderDetails.Count(), "Wrong count");
210 ········}
211
212
213 ········[Test]
214 ········public void Reload()
215 ········{
216 ············var pm = PmFactory.NewPersistenceManager();
217 ············CreateSave(pm);
218 ············OrderDetail od = (OrderDetail) order.OrderDetails.First();
219 ············pm.UnloadCache();
220 ············od = (OrderDetail) pm.FindObject(od.NDOObjectId);
221 ············decimal d = od.Price;
222 ········}
223
224 ········[Test]
225 ········public void Delete()
226 ········{
227 ············var pm = PmFactory.NewPersistenceManager();
228 ············CreateSave( pm );
229 ············pm.UnloadCache();
230 ············var q = new NDOQuery<Order>(pm);
231 ············var order = q.ExecuteSingle(true);
232 ············order.RemoveOrderDetail( order.OrderDetails.First() );
233 ············pm.Save();
234 ············pm.UnloadCache();
235 ············var count = pm.Objects<OrderDetail>().Count;
236 ············Assert.That(0 ==··count );
237
238 ············order = pm.Objects<Order>().Single(); // Throws, if count != 1
239 ············Assert.That(0 ==··order.OrderDetails.Count() );
240 ········}
241
242 ········[Test]
243 ········public void DeleteParent()
244 ········{
245 ············var pm = PmFactory.NewPersistenceManager();
246 ············CreateSave(pm);
247 ············pm.UnloadCache();
248 ············IQuery q = new NDOQuery<Order>(pm);
249 ············order = (Order) q.ExecuteSingle(true);
250 ············pm.Delete(order);
251 ············pm.Save();
252 ············pm.UnloadCache();
253 ············IList l = pm.GetClassExtent(typeof(OrderDetail));
254 ············Assert.That(0 ==··l.Count, "Wrong count #1");
255 ············l = pm.GetClassExtent(typeof(Order));
256 ············Assert.That(0 ==··l.Count, "Wrong count #2");
257 ········}
258 ····}
259 }
260