Unit testing of a class using nose

Question

Define a nose test class 'TestingCircleCreation' which tests the behavior of 'init' method with below specified four tests.

1. Define a nose test method 'test_creating_circle_with_numeric_radius', which creates a circle with radius 2.5 and check if it's radius matches to value 2.5

2. Define a nose test method 'test_creating_circle_with_negative_radius', which checks if ValueError exception is raised with the error message "radius must be between 0 and 1000 inclusive", while creating circle of radius -2.5 .

3.Define a nose test method 'test_creating_circle_with_greaterthan_radius', which checks if ValueError exception is raised with the error message "radius must be between 0 and 1000 inclusive" , while creating circle of radius 1000.1

4. Define a nose test method 'test_creating_circle_with_nonnumeric_radius', which checks if TypeError exception is raised with the error message "radius must be a number", while creating circle of radius 'hello' .

i am not getting the expected output. Please suggest

Code used:

class TestCircleCreation(unittest.TestCase):

def test_creating_circle_with_numeric_radius(self):

    c1=Circle(2.5)
    self.assert_equal(c1.radius,2.5)


def test_creating_circle_with_negative_radius(self):

    c1=Circle(2.5)
    self.assert_equal(c1.radius,2.5)
    self.assert_raises(ValueError, Circle, -2.5)


def test_creating_circle_with_greaterthan_radius(self):

    c1=Circle(2.5)
    self.assert_equal(c1.radius,2.5) 
    self.assert_raises(ValueError, Circle, 1000.1)     


def test_creating_circle_with_nonnumeric_radius(self):

    c1=Circle(2.5)
    self.assert_equal(c1.radius,2.5)
    self.assert_raises(TypeError, Circle, 'hello') 

Answer 1

from proj.circle import Circle
from nose.tools import assert_raises, eq_

class TestingCircleCreation:
    def test_creating_circle_with_numeric_radius(self):
      c=Circle(2.5)
      eq_(c.radius, 2.5)


    def test_creating_circle_with_negative_radius(self):
        with assert_raises(ValueError) as e:
          c = Circle(-2.5)
          eq_(str(e.exception), "radius must be between 0 and 1000 inclusive")



    def test_creating_circle_with_greaterthan_radius(self):
        with assert_raises(ValueError) as e:
          c = Circle(1000.1)
          eq_(str(e.exception), "radius must be between 0 and 1000 inclusive")

    def test_creating_circle_with_nonnumeric_radius(self):
        with assert_raises(TypeError) as e:
          c=Circle("hello")
          eq_(str(e.exception), "radius must be a number")



class TestCircleArea:
    def test_circlearea_with_random_numeric_radius(self):
        c1=Circle(2.5)
        eq_(c1.area(), 19.63)

    def test_circlearea_with_min_radius(self):
        c2=Circle(0)
        eq_(int(c2.area()), 0)

    def test_circlearea_with_max_radius(self):
        c3=Circle(1000)
        eq_(c3.area(), 3141592.65)

class TestCircleCircumference:
    def test_circlecircum_with_random_numeric_radius(self):
        c1=Circle(2.5)
        eq_(c1.circumference(), 15.71)

    def test_circlecircum_with_min_radius(self):
        c2=Circle(0)
        eq_(int(c2.circumference()), 0)

    def test_circlecircum_with_max_radius(self):
        c3=Circle(1000)
        eq_(c3.circumference(), 6283.19)

Answer 2

Here you go, this should work

import inspect
import re
import unittest
import math
from nose.tools import assert_raises

class Circle:

def __init__(self, radius):
    # Define initialization method:
    if not isinstance(radius, int) and not isinstance(radius, float):
        raise TypeError('radius must be a number')
    if radius < 0 or radius > 1000:
        raise ValueError('radius must be between 0 and 1000 inclusive')
    self.radius = radius

def area(self): 
    return round(math.pi * self.radius * self.radius, 2)
           
def circumference(self): 
    return round(2*math.pi*self.radius, 2)


from proj.circle import Circle
from nose.tools import assert_raises
class TestingCircleCreation:

def test_creating_circle_with_numeric_radius(self): 
    c1 = Circle(2.5)
    assert c1.radius == 2.5

def test_creating_circle_with_negative_radius(self): 
    with assert_raises(ValueError) as e:
        c = Circle(-2.5)
    assert str(e.exception) == 'radius must be between 0 and 1000 inclusive'


def test_creating_circle_with_greaterthan_radius(self):    
    with assert_raises(ValueError) as e:
        c = Circle(1000.1)
    assert str(e.exception) == 'radius must be between 0 and 1000 inclusive'   

def test_creating_circle_with_nonnumeric_radius(self): 
    with assert_raises(TypeError) as e:
        c = Circle('hello')
    assert str(e.exception) == 'radius must be a number'


class TestCircleArea:

def test_circlearea_with_random_numeric_radius(self): 
    c1 = Circle(2.5)
    assert c1.area() == 19.63
    
def test_circlearea_with_min_radius(self):
    # Define a circle 'c2' with radius 0, and check if 
    # its area is 0.
    c2 = Circle(0)
    assert c2.area() ==  0
    
def test_circlearea_with_max_radius(self): 
    c3 = Circle(1000)
    assert c3.area() ==  3141592.65



class TestCircleCircumference:

def test_circlecircum_with_random_numeric_radius(self): 
    c1 = Circle(2.5)
    assert c1.circumference() == 15.71
    
def test_circlecircum_with_min_radius(self): 
    c2 = Circle(0)
    assert c2.circumference() == 0
    
def test_circlecircum_with_max_radius(self): 
    c3 = Circle(1000)
    assert c3.circumference() == 6283.19

Answer 3

class TestingCircleCreation:

def test_creating_circle_with_numeric_radius(self):
    c1=Circle(2.5)
    assert c1.radius==2.5

def test_creating_circle_with_negative_radius(self):
    c1=Circle(2.5)
    assert c1.radius==2.5
    with assert_raises(ValueError):
        Circle(-2.5)


def test_creating_circle_with_greaterthan_radius(self):
    c1=Circle(2.5)
    assert c1.radius==2.5
    with assert_raises(ValueError):
        Circle(1000.1)

def test_creating_circle_with_nonnumeric_radius(self):
    c1=Circle(2.5)
    assert c1.radius==2.5
    with assert_raises(TypeError):
        Circle('hello')