# -*- coding: utf-8 -*-

import datetime

from rattail.db import model

class TestPurgeBatches(DataTestCase):

    def setUp(self):

        super(TestPurgeBatches, self).setUp()

        batch = model.Batch(purge=datetime.date(2014, 1, 1))

        batch.add_column('F01')

        batch.add_column('F02')

        self.session.add(batch)

        batch.create_table()

        batch = model.Batch(purge=datetime.date(2014, 3, 1))

        batch.add_column('F01')

        batch.add_column('F02')

        self.session.add(batch)

        batch.create_table()

        self.session.commit()

    def get_batch_tables_metadata(self):

        def batch_tables(name, metadata):

            return util.batch_pattern.match(name)

        metadata.reflect(only=batch_tables)

        return metadata

    def test_purging_honors_batch_purge_dates(self):

        self.assertEqual(self.session.query(model.Batch).count(), 3)

        self.assertEqual(util.purge_batches(effective_date=datetime.date(2014, 1, 15)), 1)

        self.assertEqual(self.session.query(model.Batch).count(), 2)

    def test_purging_everything_does_just_that(self):

        self.assertEqual(self.session.query(model.Batch).count(), 3)

        self.assertEqual(util.purge_batches(purge_everything=True), 3)

        self.assertEqual(self.session.query(model.Batch).count(), 0)

    # TODO: The next two tests each work if only one is enabled...but if both

    # are enabled, one will fail.  This needs more investigation, but one

    # possible cause is the "corruption" of Base.metadata when Batch.rowclass

    # is accessed?  In particular it seems *not* to be a SQLite problem, as it

    # occurred when using a PostgreSQL engine as well.

# -*- coding: utf-8 -*-

from rattail.db import model

class TestUserEmailAddress(DataTestCase):

    def extra_setup(self):

        self.user = model.User(username='fred')

        self.session.add(self.user)

        self.session.flush()

    def test_email_defaults_to_none(self):

        self.assertTrue(self.user.get_email_address() is None)

# -*- coding: utf-8 -*-

class TestAuthenticateUser(DataTestCase):

    def test_nonexistent_user_returns_none(self):

        self.assertTrue(auth.authenticate_user(self.session, u'fred', u'fredpass') is None)

    def test_correct_credentials_returns_user(self):

        fred = model.User(username=u'fred')

        auth.set_user_password(fred, u'fredpass')

        self.session.add(fred)

        self.session.commit()

# -*- coding: utf-8 -*-

from unittest import TestCase

from mock import patch, DEFAULT, Mock, MagicMock

from sqlalchemy.exc import IntegrityError

from rattail.db import model

from rattail.db.types import GPCType

from rattail.db.changes import record_changes

class SAErrorHelper(object):

    def integrity_or_flush_error(self):

        try:

            from sqlalchemy.exc import FlushError

        except ImportError:

            return IntegrityError

        else:

            return (IntegrityError, FlushError)

    #     object_session.flush.side_effect = set_uuid

    #     rowclass = batch.rowclass

    #     object_session.flush.assert_called_once_with()

    #     self.assertEqual(sorted(model.Batch._rowclasses.keys()), sorted(['some_uuid', 'fresh_uuid']))

    #     self.assertTrue(model.Batch._rowclasses['fresh_uuid'] is rowclass)

    def test_get_sqlalchemy_type(self):

        # gpc

        self.assertTrue(isinstance(model.Batch.get_sqlalchemy_type('GPC(14)'), GPCType))

        # boolean

        # string

        type_ = model.Batch.get_sqlalchemy_type('CHAR(20)')

        self.assertEqual(type_.length, 20)

        # numeric

        type_ = model.Batch.get_sqlalchemy_type('NUMBER(9,3)')

        self.assertEqual(type_.precision, 9)

        self.assertEqual(type_.scale, 3)

        # invalid

        self.assertRaises(AssertionError, model.Batch.get_sqlalchemy_type, 'CHAR(9,3)')

        self.assertRaises(AssertionError, model.Batch.get_sqlalchemy_type, 'OMGWTFBBQ')

class TestCustomerPerson(DataTestCase, SAErrorHelper):

    def test_repr(self):

        assoc = model.CustomerPerson(uuid='whatever')

import datetime

import argparse

import logging

from unittest import TestCase

from cStringIO import StringIO

from mock import patch, Mock

from fixture import TempIO

from sqlalchemy import create_engine

from sqlalchemy import func

from rattail import commands

from rattail.commands.core import ArgumentParser, date_argument

from rattail.db.auth import authenticate_user

class TestArgumentParser(TestCase):

    def test_parse_args_preserves_extra_argv(self):

        parser = ArgumentParser()

        parser.add_argument('--some-optional-arg')

        parser.add_argument('some_required_arg')

        args = parser.parse_args([

                '--some-optional-arg', 'optional-value', 'required-value',

                'some', 'extra', 'args'])

        self.assertEqual(args.some_required_arg, 'required-value')