Coverage for sm / test_multitenancy_new_models.py: 0%

1from django.test import TestCase 

2from django.contrib.auth.models import Group 

3 

4from vendor.models import Model as Vendor 

5from status.models import Model as Status 

6from location.models import Model as Location 

7from patchtime.models import Model as Patchtime 

8from servermodel.models import Model as ServerModel 

9from clustersoftware.models import Model as ClusterSoftware 

10from clusterpackagetype.models import Model as ClusterPackageType 

11from cluster.models import Model as Cluster 

12from clusterpackage.models import Model as ClusterPackage 

13from .mixins import get_tenant_model_counts 

14 

15 

16class NewTenantModelsPartitioningTest(TestCase): 

17 """Test that newly multi-tenancy-enabled models are partitioned by group.""" 

18 

19 def setUp(self) -> None: 

20 self.group_a = Group.objects.create(name="Group A") 

21 self.group_b = Group.objects.create(name="Group B") 

22 

23 self.vendor_a = Vendor.objects.create(name="Vendor A", group=self.group_a) 

24 self.vendor_b = Vendor.objects.create(name="Vendor B", group=self.group_b) 

25 

26 def test_status_same_name_in_different_groups(self) -> None: 

27 Status.objects.create(name="active", group=self.group_a) 

28 Status.objects.create(name="active", group=self.group_b) 

29 self.assertEqual(Status.objects.filter(name="active").count(), 2) 

30 

31 def test_patchtime_same_name_in_different_groups(self) -> None: 

32 Patchtime.objects.create(name="Sunday 2am", group=self.group_a) 

33 Patchtime.objects.create(name="Sunday 2am", group=self.group_b) 

34 self.assertEqual(Patchtime.objects.filter(name="Sunday 2am").count(), 2) 

35 

36 def test_location_same_name_in_different_groups(self) -> None: 

37 Location.objects.create(name="Berlin", country="DE", group=self.group_a) 

38 Location.objects.create(name="Berlin", country="DE", group=self.group_b) 

39 self.assertEqual(Location.objects.filter(name="Berlin").count(), 2) 

40 

41 def test_clusterpackagetype_same_name_in_different_groups(self) -> None: 

42 ClusterPackageType.objects.create(name="helm", group=self.group_a) 

43 ClusterPackageType.objects.create(name="helm", group=self.group_b) 

44 self.assertEqual(ClusterPackageType.objects.filter(name="helm").count(), 2) 

45 

46 def test_servermodel_same_name_in_different_groups(self) -> None: 

47 ServerModel.objects.create( 

48 name="PowerEdge R640", vendor=self.vendor_a, group=self.group_a 

49 ) 

50 ServerModel.objects.create( 

51 name="PowerEdge R640", vendor=self.vendor_b, group=self.group_b 

52 ) 

53 self.assertEqual(ServerModel.objects.filter(name="PowerEdge R640").count(), 2) 

54 

55 def test_clustersoftware_same_name_in_different_groups(self) -> None: 

56 ClusterSoftware.objects.create( 

57 name="k3s", version="1.0", vendor=self.vendor_a, group=self.group_a 

58 ) 

59 ClusterSoftware.objects.create( 

60 name="k3s", version="1.0", vendor=self.vendor_b, group=self.group_b 

61 ) 

62 self.assertEqual(ClusterSoftware.objects.filter(name="k3s").count(), 2) 

63 

64 def test_clusterpackage_same_name_in_different_groups(self) -> None: 

65 cs_a = ClusterSoftware.objects.create( 

66 name="k3s", version="1.0", vendor=self.vendor_a, group=self.group_a 

67 ) 

68 cs_b = ClusterSoftware.objects.create( 

69 name="k3s", version="1.0", vendor=self.vendor_b, group=self.group_b 

70 ) 

71 cluster_a = Cluster.objects.create( 

72 name="cluster-a", clustersoftware=cs_a, group=self.group_a 

73 ) 

74 cluster_b = Cluster.objects.create( 

75 name="cluster-b", clustersoftware=cs_b, group=self.group_b 

76 ) 

77 status_a = Status.objects.create(name="active", group=self.group_a) 

78 status_b = Status.objects.create(name="active", group=self.group_b) 

79 cpt_a = ClusterPackageType.objects.create(name="helm", group=self.group_a) 

80 cpt_b = ClusterPackageType.objects.create(name="helm", group=self.group_b) 

81 

82 ClusterPackage.objects.create( 

83 name="my-app", 

84 cluster=cluster_a, 

85 status=status_a, 

86 package_type=cpt_a, 

87 description="desc", 

88 host="10.0.0.1", 

89 group=self.group_a, 

90 ) 

91 ClusterPackage.objects.create( 

92 name="my-app", 

93 cluster=cluster_b, 

94 status=status_b, 

95 package_type=cpt_b, 

96 description="desc", 

97 host="10.0.0.2", 

98 group=self.group_b, 

99 ) 

100 self.assertEqual(ClusterPackage.objects.filter(name="my-app").count(), 2) 

101 

102 

103class QuotaCountingTest(TestCase): 

104 """Test that quota counting includes all newly tenant-aware models.""" 

105 

106 def setUp(self) -> None: 

107 self.group = Group.objects.create(name="Test Group") 

108 self.vendor = Vendor.objects.create(name="Test Vendor", group=self.group) 

109 

110 def test_status_counted_in_quota(self) -> None: 

111 count_before = get_tenant_model_counts(self.group) 

112 Status.objects.create(name="active", group=self.group) 

113 count_after = get_tenant_model_counts(self.group) 

114 self.assertEqual(count_after, count_before + 1) 

115 

116 def test_patchtime_counted_in_quota(self) -> None: 

117 count_before = get_tenant_model_counts(self.group) 

118 Patchtime.objects.create(name="Sunday 2am", group=self.group) 

119 count_after = get_tenant_model_counts(self.group) 

120 self.assertEqual(count_after, count_before + 1) 

121 

122 def test_location_counted_in_quota(self) -> None: 

123 count_before = get_tenant_model_counts(self.group) 

124 Location.objects.create(name="Berlin", country="DE", group=self.group) 

125 count_after = get_tenant_model_counts(self.group) 

126 self.assertEqual(count_after, count_before + 1) 

127 

128 def test_clusterpackagetype_counted_in_quota(self) -> None: 

129 count_before = get_tenant_model_counts(self.group) 

130 ClusterPackageType.objects.create(name="helm", group=self.group) 

131 count_after = get_tenant_model_counts(self.group) 

132 self.assertEqual(count_after, count_before + 1) 

133 

134 def test_servermodel_counted_in_quota(self) -> None: 

135 count_before = get_tenant_model_counts(self.group) 

136 ServerModel.objects.create( 

137 name="PowerEdge R640", vendor=self.vendor, group=self.group 

138 ) 

139 count_after = get_tenant_model_counts(self.group) 

140 self.assertEqual(count_after, count_before + 1) 

141 

142 def test_clustersoftware_counted_in_quota(self) -> None: 

143 count_before = get_tenant_model_counts(self.group) 

144 ClusterSoftware.objects.create( 

145 name="k3s", version="1.0", vendor=self.vendor, group=self.group 

146 ) 

147 count_after = get_tenant_model_counts(self.group) 

148 self.assertEqual(count_after, count_before + 1) 

149 

150 def test_quota_not_counted_for_other_group(self) -> None: 

151 other_group = Group.objects.create(name="Other Group") 

152 count_before = get_tenant_model_counts(self.group) 

153 Status.objects.create(name="active", group=other_group) 

154 count_after = get_tenant_model_counts(self.group) 

155 self.assertEqual(count_before, count_after) 

156 

157 def test_quota_not_counted_for_no_group(self) -> None: 

158 self.assertEqual(get_tenant_model_counts(None), 0)