test_mpl_fig.py

#!/usr/bin/env python

import os, sys
import unittest

sys.path.append('../')

from figures_tests import FigTest, BrokenFigure, EmptyFig, FigTestWithAliases
from figures_tests import FigTestAxesAliases
from axes_tests import AxWithKeywords
from ios_tests import read_stupid_data
from myplotlib import HorizontalGrid
from itertools import repeat

class TestMyFig(unittest.TestCase):

    def setUp(self):
        
        self.data = read_stupid_data('data')
        
        self.data_1 = [-1., 1., 1., -1.]

        self.formatted_data_1 = {'x_data': [self.data_1[0], self.data_1[1]],
                                 'y_data': [self.data_1[2], self.data_1[3]]}

        self.data_2 = [1., -1., -1., 1.]
        
        self.formatted_data_2 = {'x_data': [self.data_2[0], self.data_2[1]],
                                 'y_data': [self.data_2[2], self.data_2[3]]}

    def test_contructor_broken(self):
        '''Verify that the NotImplementedError is raised
        when addAxes method is not implemented.
        
        Done to prevent typos issues.
        '''
        with self.assertRaises(NotImplementedError):
            fig = BrokenFigure((self.data_1,))

    def test_constructor_default(self):
        '''Verify that the figure's attributes are set as defined in config.py.
        
        Test the default constructor and that default values are correctly 
        passed.
        '''
        fig = EmptyFig(())
        # test if the figure got the default attributes
        self.assertEqual(fig.rawdata, ())
        self.assertEqual(fig.fignum, -1)
        self.assertTrue(fig.debug)
        self.assertEqual(fig.aliases, {})
        self.assertEqual(fig.FIGSIZE, (8., 6.))
        self.assertFalse(fig.bounded_to_win)
        self.assertEqual(fig.axes, [])
        self.assertIsInstance(fig.grid, HorizontalGrid)
            
    def test_constructor_minimal(self):
        '''Verify that the rawdata are properly passed to the axe in the default case.

        Test if the rawdata are well passed in the case of a rawdata tuple.
        '''
        fig = FigTest((self.data_1,))
        # Test the axes attributes
        self.assertEqual(fig.rawdata, (self.data_1,))
        self.assertEqual(fig.axes[0].data, self.formatted_data_1)

    def test_constructor_with_multiple_dataset(self):
        '''Verify that the rawdata are properly passed to the axes in the case of multiple dataset.

        Test if the rawdata are well passed in the case of multiple dataset.
        '''
        fig = FigTestWithAliases((self.data_1, self.data_2))
        # test the axes data
        # and fig rawdata
        self.assertEqual(fig.rawdata, (self.data_1, self.data_2))
        self.assertEqual(fig.axes[0].data, self.formatted_data_1)
        self.assertEqual(fig.axes[1].data, self.formatted_data_2)
        
    def test_constructor_with_single_dataset(self):
        '''Verify that the rawdata are properly failing to the axes in the case of single dataset
 
        '''
        with self.assertRaises(TypeError):
            fig = FigTestWithAliases(12.)

        with self.assertRaises(TypeError):
            fig = FigTestWithAliases('dummy')            

        with self.assertRaises(TypeError):            
            fig = FigTestWithAliases(self.data_1)

        with self.assertRaises(TypeError):
            fig = FigTestWithAliases({'dummy': 42.})            
        
    def test_constructor_with_fig_attributes(self):
        '''Verify that the meaningful keywords are properly passed.

        Test that debug, fignum and figsize are well set accordingly to 
        the keywords given in the constructor.
        '''
        fig = FigTest((self.data_1,), fignum=42, debug=False, figsize=(6., 8.))
        # test figure attributes
        self.assertEqual(fig.fignum, 42)
        self.assertFalse(fig.debug)
        self.assertEqual(fig.FIGSIZE, (6., 8.))

    def test_constructor_with_axes_keywords(self):
        '''Verify that keywords meant for axes are well passed.

        Test that the keyword xRange given to the constructor is passed to the
        axes.
        '''
        fig = FigTest((self.data_1,), p1_x_range=[-1., 1.])
        # test axes attributes
        self.assertEqual(fig.axes[0].keywords['x_range'], [-1., 1.])

    def test_constructore_with_aliased_keywords(self):
        '''Verify that keywords meant for axes are well passed, even when aliased.

        Test that a non-aliased keyword goes to all axes (x_range) and that tagged
        keywords are well passed (p1_y_range)
        '''
        fig = FigTestAxesAliases((self.data_1, self.data_2), x_range=[-2., 2.], p1_y_range=[-3., 3.])
        # test axes attributes
        self.assertEqual(fig.axes[0].keywords['x_range'], [-2., 2.])
        self.assertEqual(fig.axes[1].keywords['x_range'], [-2., 2.])
        self.assertEqual(fig.axes[0].keywords['y_range'], [-3., 3.])
        self.assertEqual(fig.axes[1].keywords['y_range'], [-1., 1.])

    def test_update_fig_attributes(self):
        '''Verify that figure's keywords are well updated.

        Test that updatable keywords from the figure can be updated by the
        update function.
        '''

        fig = FigTestAxesAliases((self.data_1,))
        ax = fig.get_axes_by_name('p1')
        
        save_auto_keywords = fig._tagged_keywords
        
        fig.aliases.update({'alias_for_yrange': ('p1_y_range',)})
        
        fig.update(fignum=42.,
                   reformat=True,
                   formatted=False,
                   debug=False,
                   aliases={'second_alias_for_yrange': ('p1_y_range',)})

        self.assertEqual(fig.fignum, 42.)
        self.assertTrue(fig.reformat)
        self.assertFalse(fig.formatted)
        self.assertFalse(fig.debug)
        self.assertTrue("alias_for_yrange" in fig.aliases)
        self.assertTrue("second_alias_for_yrange" in fig.aliases)
        self.assertEqual(fig.aliases["alias_for_yrange"], ('p1_y_range',)) 
        self.assertEqual(fig.aliases['second_alias_for_yrange'], ('p1_y_range',))
        
        # Are the _tagged_keywords set correctly?
        
        fig.update(y_range=[12, 13], title=r"something")
        
        self.assertTrue("p1_x_range" in fig._tagged_keywords)
        self.assertTrue("p1_y_range" in fig._tagged_keywords)
        self.assertTrue("p1_title" in fig._tagged_keywords)
        
        # Do they have the correct value?
        
        self.assertEqual(fig._tagged_keywords["p1_x_range"], (ax,'x_range'))
        self.assertEqual(fig._tagged_keywords["p1_y_range"], (ax,'y_range'))
        self.assertEqual(fig._tagged_keywords["p1_title"], (ax,'title'))
        
        # Are the axes keywords set correctly?
        
        self.assertEqual(ax.keywords["y_range"], [12, 13])
        self.assertEqual(ax.keywords["title"], r"something")

        # test passing aliases
        fig.update(alias_for_yrange=[10, 31])
        self.assertEqual(ax.keywords["y_range"], [10, 31])

        # test if explicit keywords have higher priority than aliases
        fig.update(alias_for_yrange=[10, 31], p1_y_range=[31, 10])
        self.assertEqual(ax.keywords["y_range"], [31, 10])

        # test if aliases have higher priority than keywords
        fig.update(y_range=[31, 10], alias_for_yrange=[10, 31])
        self.assertEqual(ax.keywords["y_range"], [10, 31])

        # test if explicit keywords have higher priority than keywords
        fig.update(y_range=[12, 13], p1_y_range=[15, 20])
        self.assertEqual(ax.keywords["y_range"], [15, 20])
        
    def test_set_rawdata(self):
        '''Verify the well function of set_rawdata

        Test if set_rawdata works with a tuple, a MplData obj, and 
        return a false status with an array.
        '''
        fig = FigTest((self.data_1,))

        fig.update(formatted=False)
        status = False
        status = fig.set_rawdata((self.data_2,))
        self.assertTrue(fig.formatted)
        self.assertEqual(fig.rawdata, (self.data_2,))
        self.assertEqual(fig.axes[0].data, self.formatted_data_2)
        self.assertTrue(status)

        fig.update(formatted=False)
        with self.assertRaises(TypeError):
            status = fig.set_rawdata(self.data_1)

        fig.update(formatted=False)
        status = False
        status = fig.set_rawdata((12., 14., 15., 16.))
        self.assertFalse(fig.formatted)
        self.assertIsNone(fig.rawdata)
        self.assertEqual(fig.axes[0].data, self.formatted_data_2)
        self.assertFalse(status)

    def test_update_rawdata(self):
        '''Verify that the special keyword rawdata is well passed
        '''
        fig = FigTest((self.data_1,))
        fig.update(rawdata=(self.data_2,))
        self.assertTrue(fig.formatted)
        self.assertEqual(fig.rawdata, (self.data_2,))

    def test_update_axes_keywords(self):
        '''Verify that axes' keywords are well passed
        '''
        fig = FigTest((self.data_1,), x_range=[-2., 2.])
        fig.update(x_range=[-1., 1.])
        self.assertEqual(fig.axes[0].keywords['x_range'], [-1., 1.])

    def test_add_axes(self):
        '''
        '''
        fig = EmptyFig(())
        dynamic_axes = AxWithKeywords(fig)
        fig.add_axes(dynamic_axes, "dynamic_plot")
        self.assertEqual(len(fig.axes), 1)
        self.assertEqual(fig.axes[0], dynamic_axes)

    def test_get_axes_by_name(self):
        '''
        '''
        fig = FigTestWithAliases((self.data_1, self.data_2))
        ax = fig.get_axes_by_name("p2")
        self.assertEqual(ax, fig.axes[1])

    def test_format_rawdata(self):
        '''
        '''
        pass

    def test_plot(self):
        '''
        '''
        implemented=False
        self.assertFalse(implemented)

    def test_reset(self):
        '''
        '''
        implemented=False
        self.assertFalse(implemented)                

    def test_print_to_file(self):
        '''
        '''
        implemented=False
        self.assertFalse(implemented)

    def test_layout(self):
        '''
        '''
        implemented=False
        self.assertFalse(implemented)

    def test_set_grid(self):
        '''
        '''
        implemented=False
        self.assertFalse(implemented)

if __name__ == '__main__':
    unittest.main()