cuesmash 0.1.0

data/lib/cuesmash/cucumber.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+module Cuesmash
+
+  #
+  # Provides a nice interface to cucumber, allowing
+  # us to run the cucumber test suite
+  #
+  # @author [alexfish]
+  #
+  class Cucumber
+
+    # Public: the output directory for the tests
+    attr_accessor :output
+
+    # Public: the output format for the tests
+    attr_accessor :format
+
+    #
+    # Create a new instance of Cucumber
+    # @param  ios [String] The iOS version cucumber will run
+    # @param  tags [Array] The tags cucumber will run with
+    #
+    def initialize(ios, tags)
+      @ios = ios
+      @tags = tags
+    end
+
+    #
+    # Run the cucumber tests
+    #
+    def test
+      started
+
+      status = nil
+      output = ""
+      Open3.popen3 command do |stdin, out, err, wait_thr|
+
+        [out, err].each do |stream|
+          Thread.new do
+            until (line = stream.gets).nil? do
+              Logger.info line
+            end
+          end
+        end
+
+        wait_thr.join
+        status = wait_thr.value.exitstatus
+      end
+
+      if status != 0
+        Logger.info "Cucumber failed"
+        # exit status
+        status
+      else
+        completed
+      end
+    end
+
+    private
+
+    #
+    # Output a nice message for starting
+    #
+    def started
+      Logger.info "Running Cucumber"
+    end
+
+    #
+    # Output a nice message for completing
+    #
+    def completed
+      Logger.info "Cucumber Completed 👌"
+    end
+
+    #
+    # Figure out what the cucumber command is and
+    # return it
+    #
+    # @return [String] The cucumber command string
+    def command
+      command = "cucumber"
+      command += simulator_arguments if @ios
+      command += " --format #{self.format}" if self.format
+      command += " --out #{self.output}" if self.output
+      command += @tags.to_a.empty? ? "" : tag_arguments
+      command += " -c"
+
+      Logger.debug "cucumber command == #{command}"
+
+      command
+    end
+
+    #
+    # Generate the --tags arguments for the cucumber
+    # command
+    #
+    # @return [String] The --tags commands ready to go
+    def tag_arguments
+      command = ""
+      @tags.each do |tag_set|
+        command = "" unless command
+        command += " --tags #{tag_set}"
+      end
+      command
+    end
+
+    #
+    # Generate the simulator version arguments that
+    # are best for certain versions of simulators
+    #
+    # @return [String] The simulator arguments
+    def simulator_arguments
+      if @ios
+          command = " DEVICE_TARGET='iPhone Retina (4-inch) - Simulator - iOS #{@ios}'"
+      end
+
+      command
+    end
+
+  end
+end

data/lib/cuesmash/iosapp.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+module Cuesmash
+
+  #
+  # Provides an object to get information about the ios app that is being built.
+  #
+  # @author [jarod]
+  #
+  class IosApp
+
+    # Public: the path to the dir containing the built app i.e. /tmp/MyAppQWERQW/Build/Products/Debug-iphonesimulator/
+    attr_reader :app_dir
+
+    # Public: the full path including the built app i.e. /tmp/MyAppQWERQW/Build/Products/Debug-iphonesimulator/MyApp.app"
+    attr_reader :app_path
+
+    # Public: the app name i.e. MyApp.app
+    attr_reader :app_name
+
+    # Public: the xcode Derived Data temp directory
+    attr_reader :tmp_dir
+
+    #
+    # Create a new App instance
+    #
+    # @param  file_name [String] The usually is the scheme of the xcode project
+    #
+    # @return [App] A app instance
+    def initialize(file_name:)
+      @app_name = "#{file_name}" << ".app"
+      @tmp_dir = Dir.mktmpdir(file_name)
+      @app_dir = "#{@tmp_dir}" << "/Build/Products/Debug-iphonesimulator/"
+      @app_path = "#{@app_dir}" << "#{@app_name}"
+    end
+  end
+end

data/lib/cuesmash/plist.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+module Cuesmash
+
+  #
+  # Does some fun stuff with Xcode plists, cuesmash needs to update
+  # the Xcode projects plist to trick the simulator into connecting
+  # to a sinatra server instead
+  #
+  # @author [alexfish]
+  #
+  class Plist
+    # include Logging
+
+    # Public: the Scheme the plist is related to
+    attr_accessor :scheme
+    attr_accessor :tmp_dir
+    attr_accessor :plist_name
+
+    #
+    # Create a new plist instance
+    # @param  scheme [String] The scheme related to the plist
+    # @param  app_path [String] The dir where the app is going to be placed.
+    # @param  plist_name [String] Default: server_config. The name of the file with the server configurations.
+    #
+    # @return [Plist] A plist instance
+    def initialize(scheme, app_path, plist_name="server_config")
+      @scheme = scheme
+      @tmp_dir = tmp_dir
+      @plist_name = plist_name
+      @app_path = app_path
+    end
+
+    #
+    # Executes the plist tasks update and clear the old plists
+    #
+    def execute
+      started
+      update
+      clear
+
+      completed
+    end
+
+    private
+
+    #
+    # Output a nice message for starting
+    #
+    def started
+      Logger.info "Updating plist"
+    end
+
+    #
+    # Output a nice message for completing
+    #
+    def completed
+      Logger.info "Plist updated 👌"
+    end
+
+    #
+    # Update the Xcode applications server.plist file
+    # with sinatras port and URL
+    #
+    def update
+      plist_file = CFPropertyList::List.new(:file => server_plist_path)
+      plist = CFPropertyList.native_types(plist_file.value)
+
+      plist["url_preference"] = server_ip
+      plist["port_preference"] = Cuesmash::PORT
+
+      plist_file.value = CFPropertyList.guess(plist)
+      plist_file.save(server_plist_path, CFPropertyList::List::FORMAT_XML)
+    end
+
+    #
+    # Clear the existing plist from the iOS simulator
+    #
+    def clear
+      FileUtils.rm(simulator_plist_path, :force => true)
+    end
+
+    #
+    # The local IP address of the mock backend server
+    #
+    # @return [String] The mock backends IP
+    def server_ip
+      Socket.ip_address_list.find {|a| a.ipv4? && !a.ipv4_loopback?}.ip_address
+    end
+
+    #
+    # The path to the iOS simulators plist
+    #
+    # @return [String] The path to the plist
+    def simulator_plist_path
+      "#{File.expand_path('~')}/Library/Preferences/com.apple.iphonesimulator.plist"
+    end
+
+    #
+    # The path to the server config plist
+    #
+    # @return The full path to the server config plist
+    def server_plist_path
+      @app_path + "/#{@plist_name}.plist"
+    end
+
+  end
+end

data/lib/cuesmash/setup.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require 'fileutils'
+require 'uri'
+require 'rest_client'
+require 'json'
+require 'open-uri'
+
+module Cuesmash
+  class Setup
+    class << self
+      #
+      # Run the command line programs to setup appium. Based on steps from http://appium.io/slate/en/tutorial/ios.html?ruby#install-ruby
+      #
+      def setup
+        install_cucumber
+        create_features_dir
+        create_env_rb
+        install_appium_console
+        install_brew
+        install_node
+        create_travis_yml
+        create_scripts_dir
+        create_build_sh
+        create_gemfile
+      end
+
+      # TODO: the git checkouts needs to check to see if the dirs have already been
+      # checked out.
+
+      private
+
+      #
+      # Honestly all of these should be self evident as to what they do. If you still can't figure it ou
+      # come find me and I'll beat you with a ruby hammer.
+      #
+      def install_cucumber
+        command_runner(command: "gem install --no-rdoc --no-ri cucumber")
+      end
+
+      def create_features_dir
+        command_runner(command: "mkdir -p features/{support,step_definitions}")
+      end
+
+      def create_env_rb
+        download_gist(gist_id:"9fa5e495758463ee5340", final_file:"features/support/env.rb")
+      end
+
+      def install_appium_console
+        command_runner(command: "gem install --no-rdoc --no-ri appium_console")
+      end
+
+      def install_brew
+        brew_path = `which brew`
+        if brew_path == 0
+          command_runner(command: "ruby -e \"$(curl -fsSL https://raw.github.com/Homebrew/homebrew/go/install)\"")
+        else
+          Logger.info "Brew already installed."
+        end
+      end
+
+      def install_node
+        command_runner(command: "brew update; brew upgrade node; brew install node")
+      end
+
+      def create_travis_yml
+        download_gist(gist_id:"74cc418331bd81651746", final_file:".travis.yml")
+      end
+
+      def create_scripts_dir
+        puts "creating scripts dir"
+        command_runner(command: "mkdir -p scripts")
+      end
+
+      def create_build_sh
+        download_gist(gist_id:"8df9762a103c694f5773", final_file:"scripts/build.sh")
+      end
+
+      def create_gemfile
+        download_gist(gist_id:"ea786f1cf0fdbe0febb3", final_file:"Gemfile")
+      end
+
+      #
+      # Run the command line
+      # @param command: [String] The command line statement to run
+      #
+      def command_runner(command:)
+        status = nil
+        Logger.info "Starting: #{command}"
+        Open3.popen3 command do |stdin, out, err, wait_thr|
+          [out, err].each do |stream|
+            Thread.new do
+              until (line = stream.gets).nil? do
+                Logger.info line
+              end # until
+            end # Thread.new
+          end # each
+          wait_thr.join
+          status = wait_thr.value.exitstatus
+        end # Open3
+
+        if status != 0
+          Logger.info "Command failed: #{command}"
+          exit status
+        else
+          Logger.info "Finished: #{command}"
+        end
+        return
+      end # command_runner
+
+      #
+      # Download gists files without git.
+      # @param gist_id: [String] the gist id
+      # @param final_file: [String] where the final file gets saved
+      #
+      def download_gist(gist_id:, final_file:)
+        base_url = URI("https://api.github.com/gists/")
+        json = JSON.parse(RestClient.get(URI.join(base_url, gist_id).to_s))
+        file_name = json['files'].keys[0]
+        raw_url = json['files'][file_name]['raw_url']
+
+        open(final_file, 'wb') do |file|
+          file << open(raw_url).read
+        end
+      end # download_gist
+    end # class << self
+  end # Class Setup
+end # Module Cuesmash

data/lib/cuesmash/start.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require 'thor'
+require 'cuesmash'
+require 'cuesmash/setup'
+require 'byebug'
+
+module Cuesmash
+
+  CONFIG_FILE = '.cuesmash.yml'
+
+  class Start < Thor
+
+    desc 'init', 'set up the project'
+    def init
+      Cuesmash::Setup.setup
+    end
+
+    desc "test OPTIONS", "run the tests"
+    long_desc <<-LONGDESC
+      --tags -t the tags to pass to cucumber, for multiple tags pass one per tag\n
+      --output -o The output directory for the test report\n
+      --format -f The format of the test report\n
+      --server -s
+    LONGDESC
+    method_option :scheme, type: :string, aliases: "-s", desc: "the Xcode scheme to build"
+    method_option :tags, type: :array, aliases: "-t", desc: "the tags to pass to cucumber, for multiple tags pass one per tag"
+    method_option :debug, type: :boolean, default: false, aliases: "-d", desc: "turn on debug output."
+    # method_option :server, type: :string, aliases: "-r", desc: ""
+    def test
+
+      # load up the .cuesmash.yml config. If we don't find one then bail
+      if File.exists?(CONFIG_FILE)
+        config = YAML.load_file(CONFIG_FILE) if File.exists?(CONFIG_FILE)
+      else
+        say "There is no '.cuesmash.yml' file. Please create one and try again.", :red
+        return
+      end
+
+      config['devices'].each do |device, oses|
+        oses.each do |os|
+          say "\n============================\ntesting iOS #{os} on #{device}", :green
+          # byebug
+          Cuesmash::Command.execute(device: device, os: os, server: options[:server], tags: options[:tags], scheme: options[:scheme], debug: options[:debug])
+        end
+      end # device each
+    end # test
+
+    desc "demo FILE", "an example task"
+    method_option :delete, aliases: "-d", desc: "Delete the file after parsing it"
+    def demo
+      puts "options == #{options}"
+    end
+
+  end # Start class
+end # module Cuesmash

data/lib/cuesmash.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require 'optparse'
+require "open3"
+require 'cfpropertylist'
+require 'find'
+require 'socket'
+require 'fileutils'
+require 'tmpdir'
+require 'logger'
+require 'yaml'
+
+require 'cuesmash/command'
+require 'cuesmash/compiler'
+require 'cuesmash/plist'
+require 'cuesmash/cucumber'
+require 'cuesmash/appium_text'
+require 'cuesmash/iosapp'
+require 'cuesmash/appium_server'
+
+module Cuesmash
+  PORT = 4567
+
+  Logger = Logger.new(STDOUT)
+  Logger.level = ::Logger::INFO
+  Logger.formatter = proc do |serverity, time, progname, msg|
+    "\n#{msg.rstrip}"
+  end
+end

data/spec/appium_text_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Cuesmash::AppiumText do
+
+  describe "when creating a new instance" do
+    before(:all) do
+      @appiumtext = Cuesmash::AppiumText.new(platform_name: "iOS", device_name: "iPhone Simulator", platform_version: "7.1", app: "MyApp")
+    end
+
+    it "should have a platform name" do
+      @appiumtext.platform_name.should match("iOS")
+    end
+
+    it "should have a device name" do
+      @appiumtext.device_name.should match("iPhone Simulator")
+    end
+
+    it "should have a platform_version" do
+      @appiumtext.platform_version.should match("7.1")
+    end
+
+    it "should have an app name" do
+      @appiumtext.app.should match("MyApp")
+    end
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Cuesmash::Command do
+
+  describe "when executing" do
+
+    before(:each) do
+      Cuesmash::Command.stub(:compile)
+      Cuesmash::Command.stub(:parse){nil}
+    end
+  end
+
+  describe "when starting a compile" do
+
+    before(:each) do
+      @mock = double(Cuesmash::Compiler)
+      @mock.stub(:compile)
+      Cuesmash::Compiler.stub(:new){@mock}
+    end
+
+    it "should set the compilers scheme and tmp dir" do
+      Cuesmash::Compiler.should_receive(:new).with("scheme", "/tmp")
+      Cuesmash::Command.compile("scheme", "/tmp")
+    end
+
+    it "should start compiling" do
+      @mock.should_receive(:compile)
+      Cuesmash::Command.compile("scheme", "/tmp")
+    end
+  end
+
+  describe "when updating the plist" do
+
+    before(:each ) do
+      @mock = double(Cuesmash::Plist)
+      @mock.stub(:execute)
+      Cuesmash::Plist.stub(:new){@mock}
+    end
+
+    it "should set the plists scheme" do
+      Cuesmash::Plist.should_receive(:new).with("scheme", "/tmp")
+      Cuesmash::Command.update_plist("scheme", "/tmp")
+    end
+
+    it "should execute the plist update" do
+      @mock.should_receive(:execute)
+      Cuesmash::Command.update_plist("scheme", "/tmp")
+    end
+
+    describe "when running the cucumber tests" do
+
+      before(:each ) do
+        @mock = double(Cuesmash::Cucumber)
+        @mock.stub(:test)
+        Cuesmash::Cucumber.stub(:new){@mock}
+      end
+
+      it "should set the cucumber ios version" do
+        Cuesmash::Cucumber.should_receive(:new).with("ios", anything)
+        Cuesmash::Command.run_tests("ios", "tags")
+      end
+
+      it "should set the cucumber tags" do
+        Cuesmash::Cucumber.should_receive(:new).with(anything, "tags")
+        Cuesmash::Command.run_tests("ios", "tags")
+      end
+
+      it "should set the format" do
+        @cucumber = Cuesmash::Cucumber.new
+        Cuesmash::Cucumber.stub(:new){@cucumber}
+
+        @cucumber.should_receive(:format=)
+        Cuesmash::Command.run_tests(nil, nil, "format")
+      end
+
+      it "should set the output" do
+        @cucumber = Cuesmash::Cucumber.new
+        Cuesmash::Cucumber.stub(:new){@cucumber}
+
+        @cucumber.should_receive(:output=)
+        Cuesmash::Command.run_tests(nil, nil, nil, "output")
+      end
+
+      it "should start the tests" do
+        @mock.should_receive(:test)
+        Cuesmash::Command.run_tests("ios", "tags")
+      end
+
+    end
+  end
+end

data/spec/compiler_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Cuesmash::Compiler do
+
+  before(:each) do
+    Cuesmash::Compiler.any_instance.stub(:puts)
+  end
+
+  it "should have a scheme instance" do
+    compiler = Cuesmash::Compiler.new("scheme", "/tmp")
+    compiler.scheme.should match("scheme")
+  end
+
+  it "should have a tmp_dir instance" do
+    compiler = Cuesmash::Compiler.new("scheme", "/tmp")
+    compiler.tmp_dir.should match("/tmp")
+  end
+
+  describe "when generating the command" do
+
+    before(:each) do
+      Cuesmash::Compiler.any_instance.stub(:workspace)
+      @compiler = Cuesmash::Compiler.new("test-scheme", "/tmp")
+    end
+
+    it "should contain the scheme" do
+      @compiler.instance_eval{command}.should match(/test-scheme/)
+    end
+
+    it "should contain the tmp path" do
+      @compiler.instance_eval{command}.should match(/tmp/)
+    end
+  end
+
+  describe "when getting the workspacae" do
+
+    before(:each) do
+      @compiler = Cuesmash::Compiler.new(nil, "/tmp")
+      Dir.stub(:[]){["workspace-file"]}
+    end
+
+    it "should get the workspace from the current directory" do
+      @compiler.instance_eval{workspace}.should match(/workspace-file/)
+    end
+  end
+
+  describe "when compiling" do
+
+    before(:each) do
+      wait = double
+      @value = double
+      wait.stub(:value){@value}
+      wait.stub(:join)
+      Open3.stub(:popen3).and_yield(nil, nil, nil, wait)
+
+      @compiler = Cuesmash::Compiler.new(nil, "/tmp")
+    end
+
+    it "should complete if all is well" do
+      @value.stub(:exitstatus){0}
+      @compiler.compile do |complete|
+        complete.should equal(true)
+      end
+    end
+  end
+
+end