nutella_framework 0.3.1 → 0.4.0

data/lib/nutella_lib_framework/api.rb

@@ -0,0 +1,333 @@
+require 'nutella_lib'
+require 'config/runlist'
+
+module Nutella
+
+
+  # Initializes this component as a framework component
+  # @param [String] broker_hostname
+  # @param [String] component_id
+  def self.init_as_f_component( broker_hostname, component_id )
+    @app_id = nil
+    @run_id = nil
+    @component_id = component_id
+    @resource_id = nil
+    @mqtt = SimpleMQTTClient.new broker_hostname
+  end
+
+
+  # Parse command line arguments for framework level components
+  #
+  # @param [Array] args command line arguments array
+  # @return [String] broker
+  def self.parse_f_component_args(args)
+    if args.length < 1
+      STDERR.puts 'Couldn\'t read broker address from the command line, impossible to initialize component!'
+      return
+    end
+    return args[0]
+  end
+
+
+  module Net
+
+    # Provides access to the net.app sub-module
+    def Net.f; Nutella::Net::Framework end
+
+
+    # This module implements the pub/sub and request/response APIs at the framework-level
+    module Framework
+
+
+      # @!group Framework-level communication APIs
+
+      # Subscribes to a channel or to a set of channels at the framework-level.
+      #
+      # @param [String] channel the framework-level channel or filter we are subscribing to. Can contain wildcard(s)
+      # @param [Proc] callback a lambda expression that is fired whenever a message is received.
+      #   The passed callback takes the following parameters:
+      #   - [String] message: the received message. Messages that are not JSON are discarded.
+      #   - [String] channel: the framework-level channel the message was received on (optional, only for wildcard subscriptions)
+      #   - [Hash] from: the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      def self.subscribe (channel, callback)
+        Nutella::Net.subscribe_to(channel, callback, nil, nil)
+      end
+
+
+      # Un-subscribes from a framework-level channel
+      #
+      # @param [String] channel the framework-level channel we want to unsubscribe from. Can contain wildcard(s).
+      def self.unsubscribe( channel )
+        Nutella::Net.unsubscribe_to(channel, nil, nil)
+      end
+
+
+      # Publishes a message to an framework-level channel
+      #
+      # @param [String] channel the framework-level channel we want to publish the message to. *CANNOT* contain wildcard(s)!
+      # @param [Object] message the message we are publishing. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def self.publish(channel, message=nil)
+        Nutella::Net.publish_to(channel, message, nil, nil)
+      end
+
+
+      # Performs a synchronous request at the framework-level
+      #
+      # @param [String] channel the framework-level channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] message the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def self.sync_request ( channel, message=nil )
+        Nutella::Net.sync_request_to(channel, message, nil, nil)
+      end
+
+
+      # Performs an asynchronous request at the framework-level
+      #
+      # @param [String] channel the framework-level channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] message the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      # @param [Proc] callback the callback that is fired whenever a response is received. It takes one parameter (response).
+      def self.async_request ( channel, message=nil, callback )
+        Nutella::Net.async_request_to(channel, message, callback, nil, nil)
+      end
+
+
+      # Handles requests on a certain framework-level channel
+      #
+      # @param [String] channel tha framework-level channel we want to listen for requests on. Can contain wildcard(s).
+      # @param [Proc] callback a lambda expression that is fired whenever a message is received.
+      #   The passed callback takes the following parameters:
+      #   - [String] the received message (payload). Messages that are not JSON are discarded.
+      #   - [Hash] the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      #   - [*returns* Hash] The response sent back to the client that performed the request. Whatever is returned by the callback is marshaled into a JSON string and sent via MQTT.
+      def self.handle_requests( channel, callback )
+        Nutella::Net.handle_requests_on(channel, callback, nil, nil)
+      end
+
+      # @!endgroup
+
+      # ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+      # @!group Framework-level APIs to communicate at the run-level
+
+      # Allows framework-level APIs to subscribe to a run-level channel within a specific run
+      #
+      # @param [String] app_id the specific application we are subscribing to
+      # @param [String] run_id the specific run we are subscribing to
+      # @param [String] channel the run-level channel we are subscribing to. Can be wildcard.
+      # @param [Proc] callback the callback that is fired whenever a message is received on the channel.
+      #   The passed callback takes the following parameters:
+      #   - [String] message: the received message. Messages that are not JSON are discarded.
+      #   - [String] channel: the framework-level channel the message was received on (optional, only for wildcard subscriptions)
+      #   - [Hash] from: the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      def self.subscribe_to_run( app_id, run_id, channel, callback )
+        Nutella::Net.subscribe_to(channel, callback, app_id, run_id)
+      end
+
+
+      # Allows framework-level APIs to unsubscribe from a run-level channel within a specific run
+      #
+      # @param [String] app_id the specific application we are un-subscribing from
+      # @param [String] run_id the specific run we are un-subscribing from
+      # @param [String] channel the run-level channel we want to unsubscribe from. Can contain wildcard(s).
+      def self.unsubscribe_to_run( app_id, run_id, channel )
+        Nutella::Net.unsubscribe_to(channel, app_id, run_id)
+      end
+
+
+      # Allows framework-level APIs to publish to a run-level channel within a specific run
+      #
+      # @param [String] app_id the specific application we are publishing to
+      # @param [String] run_id the specific run we are publishing to
+      # @param [String] channel the run-level channel we want to publish the message to. *CANNOT* contain wildcard(s)!
+      # @param [String] message the message we are publishing. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def self.publish_to_run( app_id, run_id, channel, message )
+        Nutella::Net.publish_to(channel, message, app_id, run_id)
+      end
+
+
+      # Allows framework-level APIs to make a synchronous request to a run-level channel within a specific run
+      #
+      # @param [String] app_id the specific application we are making the request to
+      # @param [String] run_id the specific run we are making the request to
+      # @param [String] channel the channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] request the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def self.sync_request_to_run( app_id, run_id, channel, request)
+        Nutella::Net.sync_request_to(channel, request, app_id, run_id)
+      end
+
+
+      # Allows framework-level APIs to make an asynchronous request to a run-level channel within a specific run
+      #
+      # @param [String] app_id the specific application we are making the request to
+      # @param [String] run_id the specific run we are making the request to
+      # @param [String] channel the channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] request the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      # @param [Proc] callback the callback that is fired whenever a response is received. It takes one parameter (response).
+      def self.async_request_to_run( app_id, run_id, channel, request, callback)
+        Nutella::Net.async_request_to(channel, request, callback, app_id, run_id)
+      end
+
+
+      # Allows framework-level APIs to handle requests on a run-level channel within a specific run
+      #
+      # @param [String] app_id the specific application requests are coming from
+      # @param [String] run_id the specific run requests are coming from
+      # @param [String] channel we want to listen for requests on. Can contain wildcard(s).
+      # @param [Proc] callback a lambda expression that is fired whenever a message is received.
+      #   The passed callback takes the following parameters:
+      #   - [String] the received message (payload). Messages that are not JSON are discarded.
+      #   - [Hash] the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      #   - [*returns* Hash] The response sent back to the client that performed the request. Whatever is returned by the callback is marshaled into a JSON string and sent via MQTT.
+      def self.handle_requests_on_run( app_id, run_id, channel, callback )
+        Nutella::Net.handle_requests_on(channel, callback, app_id, run_id)
+      end
+
+      # @!endgroup
+
+      # ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+      # @!group Framework-level APIs to communicate at the run-level (broadcast)
+
+      # Allows framework-level APIs to subscribe to a run-level channel *for ALL runs*
+      #
+      # @param [String] channel the run-level channel we are subscribing to. Can be wildcard.
+      # @param [Proc] callback the callback that is fired whenever a message is received on the channel.
+      #   The passed callback takes the following parameters:
+      #   - [String] message: the received message. Messages that are not JSON are discarded.
+      #   - [String] app_id: the app_id of the channel the message was sent on
+      #   - [String] run_id: the run_id of the channel the message was sent on
+      #   - [Hash] from: the sender's identifiers (run_id, app_id, component_id and optionally resource_id)
+      def self.subscribe_to_all_runs( channel, callback )
+        # Check the passed callback has the right number of arguments
+        raise 'You need to pass a callback with 4 parameters (payload, app_id, run_id, from) when subscribing to all runs!' if callback.parameters.length!=4
+        # Pad channel
+        padded_channel = Nutella::Net.pad_channel(channel, '+', '+')
+        mqtt_cb = lambda do |mqtt_message, mqtt_channel|
+          begin
+            type, from, payload, _ = Nutella::Net.extract_fields_from_message mqtt_message
+            app_id, run_id = self.extract_run_id_and_app_id mqtt_channel
+            callback.call(payload, app_id, run_id, from) if type=='publish'
+          rescue JSON::ParserError
+            # Make sure the message is JSON, if not drop the message
+            return
+          rescue
+            # Check the passed callback has the right number of arguments
+            STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'payload', 'app_id', 'run_id' and 'from'"
+          end
+        end
+        # Add to subscriptions, save mqtt callback and subscribe
+        Nutella::Net.subscriptions.push padded_channel
+        Nutella::Net.callbacks.push mqtt_cb
+        Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
+      end
+
+
+      # Allows framework-level APIs to unsubscribe from a run-level channel *for ALL runs*
+      #
+      # @param [String] channel the run-level channel we want to unsubscribe from. Can contain wildcard(s).
+      def self.unsubscribe_from_all_runs( channel )
+        Nutella::Net.unsubscribe_to(channel, '+', '+')
+      end
+
+
+      # Allows framework-level APIs to publish a message to a run-level channel *for ALL runs*
+      #
+      # @param [String] channel the run-level channel we want to publish the message to. *CANNOT* contain wildcard(s)!
+      # @param [Object] message the message we are publishing. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      def self.publish_to_all_runs( channel, message )
+        Nutella.runlist.all_runs.each do |app_id, _|
+          Nutella.runlist.runs_for_app(app_id).each do |run_id|
+            Nutella::Net.publish_to(channel, message, app_id, run_id)
+          end
+        end
+      end
+
+
+      # Allows framework-level APIs to send a request to a run-level channel *for ALL runs*
+      #
+      # @param [String] channel the run-level channel we want to make the request to. *CANNOT* contain wildcard(s)!
+      # @param [Object] request the body of request. This can be,
+      #   nil/empty (default), a string, a hash and, in general, anything with a .to_json method.
+      # @param [Proc] callback the callback that is fired whenever a response is received. It takes one parameter (response).
+      def self.async_request_to_all_runs(channel, request, callback)
+        Nutella.runlist.all_runs.each do |app_id, _|
+          Nutella.runlist.runs_for_app(app_id).each do |run_id|
+            Nutella::Net.async_request_to(channel, request, callback, app_id, run_id)
+          end
+        end
+      end
+
+
+      # Allows framework-level APIs to handle requests to a run-level channel *for ALL runs*
+      #
+      # @param [String] channel tha run-level channel we want to listen for requests on. Can contain wildcard(s).
+      # @param [Proc] callback a lambda expression that is fired whenever a message is received.
+      #   The passed callback takes the following parameters:
+      #   - [String] the received message (request). Messages that are not JSON are discarded.
+      #   - [String] app_id: the app_id of the channel the request was sent on
+      #   - [String] run_id: the run_id of the channel the request was sent on
+      #   - [Hash] the sender's identifiers (from containing, run_id, app_id, component_id and optionally resource_id)
+      #   - [*returns* Hash] The response sent back to the client that performed the request. Whatever is returned by the callback is marshaled into a JSON string and sent via MQTT.
+      def self.handle_requests_on_all_runs(channel, callback)
+        # Check the passed callback has the right number of arguments
+        raise 'You need to pass a callback with 4 parameters (request, run_id, from) when handling requests!' if callback.parameters.length!=4
+        # Pad channel
+        padded_channel = Nutella::Net.pad_channel(channel, '+', '+')
+        mqtt_cb = lambda do |request, mqtt_channel|
+          begin
+            # Extract nutella fields
+            type, from, payload, id = Nutella::Net.extract_fields_from_message request
+            app_id, run_id = self.extract_run_id_and_app_id mqtt_channel
+            # Only handle requests that have proper id set
+            return if type!='request' || id.nil?
+            # Execute callback and send response
+            m = Net.prepare_message_for_response( callback.call( payload, app_id, run_id, from), id )
+            Nutella.mqtt.publish( mqtt_channel, m )
+          rescue JSON::ParserError
+            # Make sure that request contains JSON, if not drop the message
+            return
+          rescue
+            # Check the passed callback has the right number of arguments
+            STDERR.puts "The callback you passed to subscribe has the #{$!}: it needs 'request', 'app_id', 'run_id' and 'from'"
+          end
+        end
+        # Subscribe to the channel
+        Nutella.mqtt.subscribe( padded_channel, mqtt_cb )
+      end
+
+      # @!endgroup
+
+      # ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+      # @!group Framework-level APIs to communicate at the application-level
+
+      # TODO
+
+      # @!endgroup
+
+      # ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+      # @!group Framework-level APIs to communicate at the application-level (broadcast)
+
+      # TODO
+
+      # @!endgroup
+
+      private
+
+      def self.extract_run_id_and_app_id( mqtt_channel )
+        sp =  mqtt_channel.sub('/nutella/apps/', '').split('/')
+        return sp[0], sp[2]
+      end
+
+
+    end
+
+  end
+end

data/lib/tmux/tmux.rb

@@ -0,0 +1,76 @@
+module Nutella
+  
+  class Tmux
+  
+    def initialize( app_id, run_id )
+      @app_id = app_id
+      @run_id = run_id
+    end
+
+    # Creates a new window (and session if necessary) to start a run-level bot
+    def new_bot_window( bot )
+      # Create session name
+      sn = Tmux.session_name(@app_id, @run_id)
+      # Create session
+      create_tmux_window(sn, bot)
+      # Start bot
+      `tmux send-keys "cd bots/#{bot};./startup #{Nutella.config['broker']} #{@app_id} #{@run_id}" C-m`
+    end
+
+    # Creates a new window (and session if necessary) to start an app-level bot
+    def new_app_bot_window( bot )
+      # Create session name
+      sn = Tmux.app_bot_session_name(@app_id)
+      # Create session
+      create_tmux_window(sn, bot)
+      # Start bot
+      `tmux send-keys "cd bots/#{bot};./startup #{Nutella.config['broker']} #{@app_id}" C-m`
+    end
+
+    # Removes a run-level session associated to a particular run
+    def self.kill_run_session( app_id, run_id )
+      `tmux kill-session -t #{session_name(app_id, run_id)} &> /dev/null`
+    end
+
+    # Removes the app-level session associated to a particular application
+    def self.kill_app_session( app_id )
+      `tmux kill-session -t #{app_bot_session_name( app_id )} &> /dev/null`
+    end
+
+    #  Returns true if a tmux session with a certain id exists
+    def self.session_exist?( session_id )
+      system( "tmux has-session -t #{session_id} &> /dev/null" )
+    end
+
+    # Builds a session name for run-level session
+    def self.session_name( app_id, run_id )
+      "#{app_id}/#{run_id}"
+    end
+
+    # Builds a session name for an app-level session
+    def self.app_bot_session_name( app_id )
+      "#{app_id}-app-bots"
+    end
+
+
+    private
+
+    def create_tmux_window( session_name, bot )
+      # If a session already exists, simply create a new window (-n) for 'bot'.
+      # -k destroys the window if it can't be created
+      # -P prints info about creation of window
+      # If there is no sessions, let's create one (-s) and, at the same time, create a new window for the bot
+      if defined? @windows
+        `tmux new-window -kP -n #{bot} &> /dev/null`
+        @windows.push bot
+      else
+        `tmux new-session -d -s #{session_name} -n #{bot} &> /dev/null`
+        @windows = [bot]
+      end
+      # Select the last window we launched
+      `tmux select-window -t #{session_name}:#{@windows.length-1} &> /dev/null`
+    end
+      
+  end
+  
+end

data/nutella_framework.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: nutella_framework 0.3.1 ruby lib
+# stub: nutella_framework 0.4.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "nutella_framework"
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Alessandro Gnoli"]
-  s.date = "2015-02-26"
+  s.date = "2015-03-13"
   s.description = "Nutella is a framework to create and run classroom narratives"
   s.email = "tebemis@gmail.com"
   s.executables = ["nutella"]
@@ -27,46 +27,53 @@ Gem::Specification.new do |s|
     "README.md",
     "Rakefile",
     "VERSION",
-    "actors/main_interface/main_interface_bot.rb",
-    "actors/main_interface/public/index.html",
-    "actors/main_interface/startup",
-    "actors/main_interface/views/index.erb",
-    "actors/main_interface/views/not_found_404.erb",
     "bin/nutella",
     "data/index.html",
     "data/startup",
-    "lib/cli/nutella_cli.rb",
+    "framework_components/example_framework_interface/dandelion-flowers-card.jpg",
+    "framework_components/example_framework_interface/index.html",
+    "framework_components/main_interface/main_interface_bot.rb",
+    "framework_components/main_interface/public/index.html",
+    "framework_components/main_interface/startup",
+    "framework_components/main_interface/views/index.erb",
+    "framework_components/main_interface/views/not_found_404.erb",
+    "framework_components/order.json.example",
+    "framework_components/runs_list_bot/app_runs_list_bot.rb",
+    "lib/commands/broker.rb",
+    "lib/commands/checkup.rb",
+    "lib/commands/compile.rb",
+    "lib/commands/dependencies.rb",
+    "lib/commands/help.rb",
+    "lib/commands/install.rb",
+    "lib/commands/meta/command.rb",
+    "lib/commands/meta/run_command.rb",
+    "lib/commands/meta/template_command.rb",
+    "lib/commands/new.rb",
+    "lib/commands/runs.rb",
+    "lib/commands/start.rb",
+    "lib/commands/stop.rb",
+    "lib/commands/template.rb",
     "lib/config/config.rb",
-    "lib/config/current_project.rb",
+    "lib/config/current_app_utils.rb",
     "lib/config/persisted_hash.rb",
     "lib/config/runlist.rb",
-    "lib/core/command.rb",
-    "lib/core/commands/broker.rb",
-    "lib/core/commands/checkup.rb",
-    "lib/core/commands/compile.rb",
-    "lib/core/commands/dependencies.rb",
-    "lib/core/commands/help.rb",
-    "lib/core/commands/install.rb",
-    "lib/core/commands/new.rb",
-    "lib/core/commands/runs.rb",
-    "lib/core/commands/start.rb",
-    "lib/core/commands/stop.rb",
-    "lib/core/commands/template.rb",
+    "lib/core/nutella_cli.rb",
     "lib/core/nutella_core.rb",
-    "lib/core/run_command.rb",
-    "lib/core/template_command.rb",
-    "lib/core/tmux.rb",
     "lib/logging/nutella_logger-remote.rb",
     "lib/logging/nutella_logger.rb",
     "lib/logging/nutella_logging.rb",
     "lib/nutella_framework.rb",
+    "lib/nutella_lib_framework/api.rb",
+    "lib/tmux/tmux.rb",
     "nutella_framework.gemspec",
-    "test/config/test_config.rb",
-    "test/config/test_project.rb",
+    "test/commands/test_cmd_cli_params_parsing.rb",
+    "test/commands/test_command_template.rb",
+    "test/config/test_current_app_utils.rb",
+    "test/config/test_persisted_hash.rb",
     "test/config/test_runlist.rb",
+    "test/framework_apis/test_framework_api.rb",
     "test/helper.rb",
-    "test/logging/test_logging.rb",
-    "test/test_run_command.rb"
+    "test/logging/test_logging.rb"
   ]
   s.homepage = "https://github.com/nutella-framework/nutella_framework"
   s.licenses = ["MIT"]
@@ -82,8 +89,10 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<logging>, [">= 1.8.2", "~> 1.8"])
       s.add_runtime_dependency(%q<git>, [">= 1.2.8", "~> 1.2"])
       s.add_runtime_dependency(%q<sinatra>, [">= 1.4.5", "~> 1.4.5"])
+      s.add_runtime_dependency(%q<thin>, [">= 1.6.3", "~> 1.6.3"])
       s.add_runtime_dependency(%q<nokogiri>, [">= 1.6.3", "~> 1.6.3"])
       s.add_runtime_dependency(%q<slop>, [">= 4.0.0", "~> 4.0.0"])
+      s.add_runtime_dependency(%q<nutella_lib>, [">= 0.4.0", "~> 0.4.0"])
       s.add_development_dependency(%q<shoulda>, [">= 3", "~> 3"])
       s.add_development_dependency(%q<yard>, [">= 0.8.7", "~> 0.8"])
       s.add_development_dependency(%q<rdoc>, [">= 4.0", "~> 4.0"])
@@ -96,8 +105,10 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<logging>, [">= 1.8.2", "~> 1.8"])
       s.add_dependency(%q<git>, [">= 1.2.8", "~> 1.2"])
       s.add_dependency(%q<sinatra>, [">= 1.4.5", "~> 1.4.5"])
+      s.add_dependency(%q<thin>, [">= 1.6.3", "~> 1.6.3"])
       s.add_dependency(%q<nokogiri>, [">= 1.6.3", "~> 1.6.3"])
       s.add_dependency(%q<slop>, [">= 4.0.0", "~> 4.0.0"])
+      s.add_dependency(%q<nutella_lib>, [">= 0.4.0", "~> 0.4.0"])
       s.add_dependency(%q<shoulda>, [">= 3", "~> 3"])
       s.add_dependency(%q<yard>, [">= 0.8.7", "~> 0.8"])
       s.add_dependency(%q<rdoc>, [">= 4.0", "~> 4.0"])
@@ -111,8 +122,10 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<logging>, [">= 1.8.2", "~> 1.8"])
     s.add_dependency(%q<git>, [">= 1.2.8", "~> 1.2"])
     s.add_dependency(%q<sinatra>, [">= 1.4.5", "~> 1.4.5"])
+    s.add_dependency(%q<thin>, [">= 1.6.3", "~> 1.6.3"])
     s.add_dependency(%q<nokogiri>, [">= 1.6.3", "~> 1.6.3"])
     s.add_dependency(%q<slop>, [">= 4.0.0", "~> 4.0.0"])
+    s.add_dependency(%q<nutella_lib>, [">= 0.4.0", "~> 0.4.0"])
     s.add_dependency(%q<shoulda>, [">= 3", "~> 3"])
     s.add_dependency(%q<yard>, [">= 0.8.7", "~> 0.8"])
     s.add_dependency(%q<rdoc>, [">= 4.0", "~> 4.0"])

data/test/commands/test_cmd_cli_params_parsing.rb

@@ -0,0 +1,56 @@
+require 'helper'
+
+module Nutella
+
+  class TestCmdCLIParamsParsing < MiniTest::Test
+
+    def setup
+      @run_cmd = RunCommand.new
+    end
+
+
+    should 'parse app long argument' do
+      params =  @run_cmd.parse_cli_parameters ['--with=bot1,bot2,bot3']
+      assert_equal %w(bot1 bot2 bot3), params[:with]
+    end
+
+    should 'parse without long argument' do
+      params =  @run_cmd.parse_cli_parameters ['--without=botA,botB,botC']
+      assert_equal %w(botA botB botC), params[:without]
+    end
+
+    should 'parse with long argument' do
+      params =  @run_cmd.parse_cli_parameters ['--with=botX,botY,botZ']
+      assert_equal %w(botX botY botZ), params[:with]
+    end
+
+    should 'parse one short argument' do
+      params =  @run_cmd.parse_cli_parameters ['-w=bot1,bot2,bot3']
+      assert_equal %w(bot1 bot2 bot3), params[:with]
+    end
+
+    should 'parse two long arguments' do
+      params =  @run_cmd.parse_cli_parameters %w(--with=bot1,bot2,bot3 --without=botA,botB,botC)
+      assert_equal %w(bot1 bot2 bot3), params[:with]
+      assert_equal %w(botA botB botC), params[:without]
+    end
+
+    should 'parse two short arguments' do
+      params =  @run_cmd.parse_cli_parameters %w(-wo=bot1,bot2,bot3 -w=botA,botB,botC)
+      assert_equal %w(bot1 bot2 bot3), params[:without]
+      assert_equal %w(botA botB botC), params[:with]
+    end
+
+    should 'parse one short and one long argument' do
+      params =  @run_cmd.parse_cli_parameters %w(--with=bot1,bot2,bot3 -wo=botA,botB,botC)
+      assert_equal %w(bot1 bot2 bot3), params[:with]
+      assert_equal %w(botA botB botC), params[:without]
+    end
+
+    should 'raise an exception when trying to parse params that do not exist' do
+      assert_raises (StandardError) { @run_cmd.parse_cli_parameters %w(--wit=bot1,bot2,bot3 -o=botA,botB,botC) }
+    end
+
+  end
+
+end

data/test/commands/test_command_template.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+module Nutella
+
+  class TestCommandTemplate < MiniTest::Test
+
+    # 1. Create a fake app
+    # New.new.run ['test_app']
+    # Dir.chdir 'test_app'
+    # Nutella::Install.new.run ['basic-ruby-bot', 'bot1']
+    # Dir.chdir '..'
+
+    # 2. Perform tests
+    # should 'this is my first test' do
+    #   Dir.chdir 'test_app'
+    #   # Test code here
+    #   Dir.chdir '..'
+    # end
+    #
+    # should 'this is my second test' do
+    #   Dir.chdir 'test_app'
+    #   # Test code here
+    #   Dir.chdir '..'
+    # end
+
+    # 3. Cleanup
+    # MiniTest.after_run { FileUtils.rm_r 'test_app' }
+
+  end
+
+end

data/test/config/test_current_app_utils.rb

@@ -0,0 +1,34 @@
+require 'helper'
+
+module Nutella
+  
+  class TestCurrentAppUtils < MiniTest::Test
+
+    # def setup
+    #   Dir.chdir NUTELLA_HOME
+    #   Nutella.execute_command( 'new', ['test_app'] )
+    #   Dir.chdir "#{NUTELLA_HOME}test_app"
+    # end
+    #
+    #
+    # should 'return true if the dir is a nutella app' do
+    #   assert Nutella.current_app.exist?
+    # end
+    #
+    # should 'return false if the dir is not a nutella app' do
+    #   Dir.chdir NUTELLA_HOME
+    #   refute Nutella.current_app.exist?
+    # end
+    #
+    # should 'return the correct version of nutella as read from the app configuration file' do
+    #   assert_equal File.open("#{NUTELLA_HOME}VERSION", "rb").read, Nutella.current_app.config['nutella_version']
+    # end
+    #
+    #
+    # def teardown
+    #   FileUtils.rm_rf "#{NUTELLA_HOME}test_app"
+    #   Dir.chdir NUTELLA_HOME
+    # end
+
+  end
+end