Lab 5 ci/cd

.github/workflows/main.yml

@@ -0,0 +1,23 @@
+name: CI/CD
+
+on: 
+  push:
+    branches: ["lab_5_CI/CD"]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.12'
+
+      - name: Run tests
+        run: python -m unittest

circle.py

@@ -2,9 +2,16 @@
 
 
 def area(r):
+    if not isinstance(r, (int, float)):
+        raise TypeError("Value must be number")
+    if r < 0:
+        raise ValueError("Value must be positive")
     return math.pi * r * r
 
 
 def perimeter(r):
+    if not isinstance(r, (int, float)):
+        raise TypeError("Value must be number")
+    if r < 0:
+        raise ValueError("Value must be positive")
     return 2 * math.pi * r
-

rectangle.py

@@ -0,0 +1,15 @@
+
+def area(a, b):
+    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
+        raise TypeError("Values must be numbers")
+    if a < 0 or b < 0:
+        raise ValueError("Values must be positive")
+    return a * b
+
+
+def perimeter(a, b):
+    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
+        raise TypeError("Values must be numbers")
+    if a < 0 or b < 0:
+        raise ValueError("Values must be positive")
+    return 2 * a + 2 * b

square.py

@@ -1,7 +1,14 @@
-
 def area(a):
+    if not isinstance(a, (int, float)):
+        raise TypeError("Value must be number")
+    if a < 0:
+        raise ValueError("Value must be positive")
     return a * a
 
 
 def perimeter(a):
+    if not isinstance(a, (int, float)):
+        raise TypeError("Value must be number")
+    if a < 0:
+        raise ValueError("Value must be positive")
     return 4 * a

test_circle.py

@@ -0,0 +1,44 @@
+import circle
+import unittest
+
+
+class CircleTestCase(unittest.TestCase):
+    def test_area_zero(self):
+        res = circle.area(0)
+        self.assertEqual(res, 0)
+
+    def test_area_negative(self):
+        with self.assertRaises(ValueError):
+            circle.area(-10)
+
+    def test_area_str_input(self):
+        with self.assertRaises(TypeError):
+            circle.area("a")
+
+    def test_area_none_value(self):
+        with self.assertRaises(TypeError):
+            circle.area(None)
+
+    def test_area_big_value(self):
+        res = circle.area(10**10)
+        self.assertEqual(res, 3.1415926535897933e+20 )
+
+    def test_area_small_velue(self):
+        res = circle.area(10 ** - 10)
+        self.assertEqual(res, 3.1415926535897936e-20)
+
+    def test_perimeter_zero(self):
+        res = circle.perimeter(0)
+        self.assertEqual(res, 0)
+
+    def test_perimeter_negative(self):
+        with self.assertRaises(ValueError):
+            circle.perimeter(-10)
+
+    def test_perimeter_str_input(self):
+        with self.assertRaises(TypeError):
+            circle.perimeter("a")
+
+    def test_perimeter_none_value(self):
+        with self.assertRaises(TypeError):
+            circle.perimeter(None)

test_rectangle.py

@@ -0,0 +1,56 @@
+import rectangle
+import unittest
+
+
+class RectangleTestCase(unittest.TestCase):
+    def test_area_zero(self):
+        res = rectangle.area(10, 0)
+        self.assertEqual(res, 0)
+
+    def test_area_square(self):
+        res = rectangle.area(10, 10)
+        self.assertEqual(res, 100)
+
+    def test_area_negative(self):
+        with self.assertRaises(ValueError):
+            rectangle.area(-10, 0)
+
+    def test_area_str_input(self):
+        with self.assertRaises(TypeError):
+            rectangle.area("a", 10)
+
+    def test_area_none_value(self):
+        with self.assertRaises(TypeError):
+            rectangle.area(None, 10)
+        with self.assertRaises(TypeError):
+            rectangle.area(10, None)
+
+    def test_area_big_value(self):
+        res = rectangle.area(10**10, 10**5)
+        self.assertEqual(res, 1000000000000000 )
+
+    def test_area_small_velue(self):
+        res = rectangle.area(10 ** - 10, 10 ** 5)
+        self.assertEqual(res, 1e-05)
+
+    def test_perimeter_zero(self):
+        res = rectangle.perimeter(10, 0)
+        self.assertEqual(res, 20)
+
+    def test_perimeter_square(self):
+        res = rectangle.perimeter(10, 10)
+        self.assertEqual(res, 40)
+
+    def test_perimeter_negative(self):
+        with self.assertRaises(ValueError):
+            rectangle.perimeter(-10, 0)
+
+    def test_perimeter_str_input(self):
+        with self.assertRaises(TypeError):
+            rectangle.perimeter("a", 0)
+
+    def test_perimeter_none_value(self):
+        with self.assertRaises(TypeError):
+            rectangle.perimeter(None, 10)
+        with self.assertRaises(TypeError):
+            rectangle.perimeter(10, None)

test_square.py

@@ -0,0 +1,44 @@
+import square
+import unittest
+
+
+class SquareTestCase(unittest.TestCase):
+    def test_area_zero_int(self):
+        res = square.area(0)
+        self.assertEqual(res, 0)
+
+    def test_area_negative(self):
+        with self.assertRaises(ValueError):
+            square.area(-10)
+
+    def test_area_str_input(self):
+        with self.assertRaises(TypeError):
+            square.area("a")
+
+    def test_area_none_value(self):
+        with self.assertRaises(TypeError):
+            square.area(None)
+
+    def test_area_big_value(self):
+        res = square.area(10**10)
+        self.assertEqual(res, 100000000000000000000)
+
+    def test_area_small_velue(self):
+        res = square.area(10 ** - 10)
+        self.assertEqual(res, 1.0000000000000001e-20)
+
+    def test_perimeter_zero(self):
+        res = square.perimeter(0)
+        self.assertEqual(res, 0)
+
+    def test_perimeter_negative(self):
+        with self.assertRaises(ValueError):
+            square.perimeter(-10)
+
+    def test_perimeter_str_input(self):
+        with self.assertRaises(TypeError):
+            square.perimeter("a")
+
+    def test_perimeter_none_value(self):
+        with self.assertRaises(TypeError):
+            square.perimeter(None)

test_triangle.py

@@ -0,0 +1,74 @@
+import triangle
+import unittest
+
+
+class TriangleTestCase(unittest.TestCase):
+    def test_area_zero_int(self):
+        res = triangle.area(10, 0)
+        self.assertEqual(res, 0)
+
+    def test_area_zero_float(self):
+        res = triangle.area(10.6, 0)
+        self.assertEqual(res, 0)
+
+    def test_area_negative(self):
+        with self.assertRaises(ValueError):
+            triangle.area(-10, 10)
+        with self.assertRaises(ValueError):
+            triangle.area(10, -10)
+
+    def test_area_str_input(self):
+        with self.assertRaises(TypeError):
+            triangle.area("a", 10)
+        with self.assertRaises(TypeError):
+            triangle.area(10, "a")
+
+    def test_area_negative(self):
+        with self.assertRaises(ValueError):
+            triangle.perimeter(-10, 10, 10)
+
+    def test_area_none_value(self):
+        with self.assertRaises(TypeError):
+            triangle.area(None, 10)
+        with self.assertRaises(TypeError):
+            triangle.area(10, None)
+
+    def test_area_big_value(self):
+        res = triangle.area(10**10, 10**5)
+        self.assertEqual(res, 500000000000000.0)
+
+    def test_area_small_velue(self):
+        res = triangle.area(10 ** - 10, 10 ** 5)
+        self.assertEqual(res,  5e-06)
+
+    def test_perimeter_zero_int(self):
+        res = triangle.perimeter(10, 0, 20)
+        self.assertEqual(res, 30)
+
+    def test_perimeter_zero_float(self):
+        res = triangle.perimeter(10.5, 0, 10.5)
+        self.assertEqual(res, 21)
+
+    def test_perimeter_equilateral_int(self):
+        res = triangle.perimeter(10, 10, 10)
+        self.assertEqual(res, 30)
+
+    def test_perimeter_equilateral_float(self):
+        res = triangle.perimeter(10.5, 10.5, 10.5)
+        self.assertEqual(res, 31.5)
+
+    def test_perimetr_str_input(self):
+        with self.assertRaises(TypeError):
+            triangle.perimeter("a", 50, 50)
+        with self.assertRaises(TypeError):
+            triangle.perimeter(50, "a", 50)
+        with self.assertRaises(TypeError):
+            triangle.perimeter(50, 50, "a")
+
+    def test_perimeter_none_value(self):
+        with self.assertRaises(TypeError):
+            triangle.perimeter(None, 10, 50)
+        with self.assertRaises(TypeError):
+            triangle.perimeter(10, None, 50)
+        with self.assertRaises(TypeError):
+            triangle.perimeter(10, 10, None)

triangle.py

@@ -0,0 +1,14 @@
+def area(a, h):
+    if not isinstance(a, (int, float)) or not isinstance(h, (int, float)):
+        raise TypeError("Values must be numbers")
+    if a < 0 or h < 0:
+        raise ValueError("Values must be positive")
+    return a * h / 2
+
+
+def perimeter(a, b, c):
+    if not isinstance(a, (int, float)) or not isinstance(b, (int, float) or not isinstance(c, (int, float))):
+        raise TypeError("Values must be numbers")
+    if a < 0 or b < 0 or c < 0:
+        raise ValueError("Values must be positive")
+    return a + b + c