CLI refactoring (#22)

* Abstract commands to classes: ValidateCommand

* Add Copyright in new files

* Use ValidateCommand class

* Handle exit in cli_tool.py

* Remove old test for validate command

* Add command abstraction for Create

* Update tests for update command

* Add delete command

* Refactor CloudFormation commands

* Refactor start and stop commands

* Add Upload Tasks command

* Refactor exec command

* Reorg commands

* Reorg tests

* Refactor invoke command

* Refactoring Config

* Refactor CLI Config

* Refactor CliTool class

* Fix CliTool

* Update command summary to print

* Fix read config with default environment settings

* Re-org test files

* Clean tests

* Fix and test execution for Inovke command

* Complete AWS profile tests and clean tests names

* Move code to cloudoformation commands

* Move code to CloudFormation command

* Update Readme

* Inject config file to CLI Tool

* Fix to include template in CloudFormation commands

Author: javibravo

README.md

@@ -4,12 +4,12 @@
 ![LambdaCron](./lambda-cron-diagram.png "LambdaCron")
 
 **LambdaCron** is a serverless cron tool. It provides a way to run scheduled tasks
-on AWS cloud and all managed by a command line tool ([LambdaCron CLI](#lambdacron-cli)).
+on AWS cloud, all managed by a command line tool ([LambdaCron CLI](#lambdacron-cli)).
 
 Tasks are scheduled using the same syntax for expressions as linux 
 [crontab](https://help.ubuntu.com/community/CronHowto).
 
-**LambdaCron** offer 3 different type of task to run:
+**LambdaCron** offer 4 different type of task to run:
 
 * **Queue task**: send message to AWS SQS queue.
 * **Lambda task**: invoke AWS lambda function.
@@ -20,30 +20,30 @@ Tasks are defined in YAML files and are stored in a S3 bucket.
 
 ## LambdaCron CLI
 
-**LambdaCron** providfe a CLI tool that allow to manage you cron tasks from you localhost,
-without needing to access to AWS console.
+**LambdaCron** provide a CLI tool that allow to manage your cron tasks from you localhost,
+no need to access to AWS console.
 
 Also it allows to run multiple environments with different settings. As many environments
 as desired can be set up.
 
 ### Settings
 
-Custom settings from environments are set in a YAML file located in user home and
-called **~/.lambda-cron.yml**.
+Custom settings for environments are set in a YAML file located in user home, it must be
+called: **~/.lambda-cron.yml**.
 
 There are 3 levels of preferences for settings:
 
 * Environment: Custom values for an specific environment.
 * Global: Custom values that will have effect to all environments created.
-* Default: Default value for options in case no custom values are specified (by environment or globally)
+* Default: Default values in case no custom values are specified (by environment or globally)
 
 Highest level of preference is *Environment*, followed by *Global* and finally *Default*. Each option 
 in the settings can set the value from different levels. Higher level of preference overwrite lower levels.
 
-Settings are saved in a YAML file. Each environment is defined with a root key the YAML
-as the global settings with the key *global*.
+Settings are saved in a YAML file. Each environment is defined with a root key in the YAML,
+global settings are identified with the key *global*.
 
-Following are the available options:
+Options available:
 
 #### bucket
 
@@ -83,7 +83,7 @@ More info for [frequency](#frequency)
 
 #### alarm
 
-Alarm can be set up using CloudWatch metrics. It use the following parameters:
+Alarm can be set up using CloudWatch metrics. It uses following parameters:
 
 * enabled
 * email (Required if alarm is enabled).
@@ -98,7 +98,7 @@ alarm:
 
 #### enabled
 
-It allows to enabled/disabled the cron.
+It allows to enabled/disabled the cron (CloudWatch event).
 
 ```yaml
 enabled: True

lambda_cron/cli/cli_config.py

@@ -19,112 +19,129 @@
 DEFAULT_BUCKET_PATTERN = 'lambda-cron-{environment}'
 
 
-def get_package_root_directory():
-    return os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), '../'))
-
-
-def get_cli_config_file_path():
+def get_default_cli_config_file_path():
     return os.path.expanduser('~/.lambda-cron.yml')
 
 
-def get_jsonschema_file_path():
-    return os.path.join(get_package_root_directory(), 'schema.json')
+class LambdaCronConfigFileNotFound(Exception):
+    pass
 
 
-def load_config():
-    if os.path.exists(get_cli_config_file_path()):
-        with open(get_cli_config_file_path(), 'r') as config_file:
+def load_config(file_path):
+    if os.path.exists(file_path):
+        with open(file_path, 'r') as config_file:
             return yaml.load(config_file)
-    return False
+    raise LambdaCronConfigFileNotFound('Config file not found: {}'.format(file_path))
 
 
-class CliConfig:
+class CliConfigParser:
 
-    def __init__(self, environment):
-        self.environment = environment
-        self.bucket = DEFAULT_BUCKET_PATTERN.format(environment=self.environment)
-        self.enabled = True
-        self.alarm_enabled = False
-        self.alarm_email = ''
-        self.hours = 1
-        self.minutes = False
+    DEFAULT_ENABLED = True
+    DEFAULT_ALARM_ENABLED = False
+    DEFAULT_ALARM_EMAIL = ''
 
-        self.config = load_config()
-        self.set_bucket()
-        self.set_enabled()
-        self.set_alarm()
-        self.set_frequency()
+    def __init__(self, config_file_path):
+        self.file_config = load_config(config_file_path)
+        self.environment = None
 
-    def is_environment_in_config_file(self):
-        return self.config and (self.environment in self.config)
+    def get_config(self, environment):
+        self.environment = environment
+        cli_config = CliConfig(self.environment)
+        cli_config.bucket = self._get_bucket()
+        cli_config.enabled = self._get_enabled()
+        cli_config.alarm_enabled, cli_config.alarm_email = self._get_alarm()
+        self._set_frequency(cli_config)
+        return cli_config
 
-    def is_custom_options(self, option):
-        return self.is_environment_in_config_file() and (option in self.config[self.environment])
+    def _is_environment_in_config_file(self):
+        return self.file_config and (self.environment in self.file_config)
 
-    def is_global_option(self, option):
-        return self.config and ('all' in self.config) and (option in self.config['all'])
+    def _is_custom_options(self, option):
+        return self._is_environment_in_config_file() and (option in self.file_config[self.environment])
 
-    def get_config_option(self, option):
+    def _is_global_option(self, option):
+        return self.file_config and ('all' in self.file_config) and (option in self.file_config['all'])
+
+    def _get_config_option(self, option):
         option_value = None
-        if self.is_custom_options(option):
-            option_value = self.config[self.environment][option]
-        elif self.is_global_option(option):
-            option_value = self.config['all'][option]
+        if self._is_custom_options(option):
+            option_value = self.file_config[self.environment][option]
+        elif self._is_global_option(option):
+            option_value = self.file_config['all'][option]
         return option_value
 
-    def set_alarm(self):
-        alarm_config = self.get_config_option('alarm')
+    def _get_alarm(self):
+        alarm_config = self._get_config_option('alarm')
 
         if not alarm_config:
-            return
+            return self.DEFAULT_ALARM_ENABLED, self.DEFAULT_ALARM_EMAIL
 
-        self.alarm_enabled = alarm_config['enabled']
-        if not isinstance(self.alarm_enabled, bool):
+        alarm_enabled = alarm_config['enabled']
+        if not isinstance(alarm_enabled, bool):
             raise Exception("Settings for 'alarm.enabled' must be a bool value")
-        if self.alarm_enabled:
+        alarm_email = self.DEFAULT_ALARM_EMAIL
+        if alarm_enabled:
             if 'email' not in alarm_config:
                 raise Exception("Email must be provided when alarm is enabled")
-            self.alarm_email = alarm_config['email']
-
-    def set_bucket(self):
-        if self.is_custom_options('bucket'):
-            self.bucket = self.config[self.environment]['bucket']
-        elif self.is_global_option('bucket'):
-            if '{environment}' in self.config['all']['bucket']:
-                self.bucket = self.config['all']['bucket'].format(environment=self.environment)
+            alarm_email = alarm_config['email']
+
+        return alarm_enabled, alarm_email
+
+    def _get_bucket(self):
+        if self._is_custom_options('bucket'):
+            return self.file_config[self.environment]['bucket']
+        elif self._is_global_option('bucket'):
+            if '{environment}' in self.file_config['all']['bucket']:
+                return self.file_config['all']['bucket'].format(environment=self.environment)
             else:
-                self.bucket = self.config['all']['bucket'] + "-{}".format(self.environment)
+                return self.file_config['all']['bucket'] + "-{}".format(self.environment)
+        else:
+            return DEFAULT_BUCKET_PATTERN.format(environment=self.environment)
 
-    def get_time_key_value(self, config_every):
+    @staticmethod
+    def _get_time_key_value(config_every):
         time_key = None
         if 'hours' in config_every:
             time_key = 'hours'
 
         if 'minutes' in config_every:
             if time_key is not None:
-                raise Exception("Only one of 'hours' or 'minutes' must be used for the frequency ('every'). Both are not allowed.")
+                raise Exception(
+                    "Only one of 'hours' or 'minutes' must be used for the frequency ('every'). Both are not allowed.")
             time_key = 'minutes'
 
         if time_key is None:
             raise Exception("Invalid time key used for frequency ('every'). Allowed keys: 'hours' or 'minutes'")
 
         return time_key, int(config_every[time_key])
 
-    def set_frequency(self):
-        config_every = self.get_config_option('every')
+    def _set_frequency(self, cli_config):
+        config_every = self._get_config_option('every')
         if not config_every:
             return
 
-        time_key, time_value = self.get_time_key_value(config_every)
-        self.hours = False
-        self.minutes = False
-        setattr(self, time_key, time_value)
+        cli_config.hours = cli_config.minutes = False
+        time_key, time_value = self._get_time_key_value(config_every)
+        setattr(cli_config, time_key, time_value)
 
-    def set_enabled(self):
-        enabled_default_value = self.enabled
-        self.enabled = self.get_config_option('enabled')
-        if self.enabled is None:
-            self.enabled = enabled_default_value
+    def _get_enabled(self):
+        enabled = self._get_config_option('enabled')
+        if enabled is None:
+            return self.DEFAULT_ENABLED
 
-        if not isinstance(self.enabled, bool):
+        if not isinstance(enabled, bool):
             raise Exception("Settings for 'enabled' must be a bool value")
+
+        return enabled
+
+
+class CliConfig:
+
+    def __init__(self, environment):
+        self.environment = environment
+        self.bucket = DEFAULT_BUCKET_PATTERN.format(environment=self.environment)
+        self.enabled = True
+        self.alarm_enabled = False
+        self.alarm_email = ''
+        self.hours = 1
+        self.minutes = False