cuesmash 0.1.7.1 → 0.1.9

data/lib/cuesmash/iosapp.rb

@@ -1,14 +1,14 @@
 #!/usr/bin/env ruby
 # coding: utf-8
 
+require 'cuesmash/app'
+
 module Cuesmash
 
   #
   # Provides an object to get information about the ios app that is being built.
   #
-  # @author [jarod]
-  #
-  class IosApp
+  class IosApp < App
 
     # Public: the path to the dir containing the built app i.e. /tmp/MyAppQWERQW/Build/Products/Debug-iphonesimulator/
     attr_reader :app_dir
@@ -26,23 +26,17 @@ module Cuesmash
     # Create a new App instance
     #
     # @param  file_name [String] The usually is the scheme of the xcode project
-    # @param travis_build [Boolean] if the build is running on travis-ci
+    # @param build_configuration [String] which iOS build configuration to run i.e. Release, Debug
     #
     # @return [App] A app instance
-    def initialize(file_name:, travis_build: false, build_configuration:)
+    def initialize(file_name:, build_configuration:)
       @app_name = "#{file_name}" << ".app"
       @tmp_dir = Dir.mktmpdir(file_name)
       @build_configuration = build_configuration
 
-      # if we are running this on travis then we want to build inside the project
-      # dir (it's a VM so it gets cleaned up each run). Otherwise let's create
-      # our own tmp dir for each build.
-      if travis_build
-        @app_dir = "./build/Release-iphonesimulator/"
-      else
-        @app_dir = "#{@tmp_dir}" << "/#{@build_configuration}-iphonesimulator/"
-      end
+      @app_dir = "#{@tmp_dir}" << "/#{@build_configuration}-iphonesimulator/"
+  
       @app_path = "#{@app_dir}" << "#{@app_name}"
     end
-  end
-end
+  end # class IosApp
+end # module Cuesmash

data/lib/cuesmash/ioscompiler.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+module Cuesmash
+
+  #
+  # iOS Specific compiler
+  # 
+  class IosCompiler < Compiler
+
+    attr_accessor :scheme
+    attr_accessor :tmp_dir
+    attr_accessor :build_configuration
+
+    def initialize(scheme, tmp_dir, build_configuration)
+      @scheme = scheme
+      @tmp_dir = tmp_dir
+      @build_configuration = build_configuration
+    end
+
+    #
+    # Generate the string to be used as the xcode build command
+    # using the scheme ivar
+    #
+    # @return [String] The full xcode build command with args
+    def command
+      xcode_command = "set -o pipefail && xcodebuild #{workspace} -scheme #{@scheme} -derivedDataPath #{@tmp_dir} -configuration #{@build_configuration} OBJROOT=#{@tmp_dir} SYMROOT=#{@tmp_dir} -sdk iphonesimulator build | bundle exec xcpretty -c"
+
+      Logger.info "xcode_command == #{xcode_command}"
+      xcode_command
+    end # command
+
+    #
+    # Looks in the current directory for the workspace file and
+    # gets it's name if there is one
+    #
+    # @return [String] The name of the workspace file that was found along with the -workspace flag
+    def workspace
+      wp = Dir["*.xcworkspace"].first
+      if wp
+        flag = "-workspace #{wp}"
+        Logger.debug "workspace == #{wp}"
+        return flag
+      else
+        Logger.debug "no workspace found"
+        return wp
+      end
+    end # workspace
+  end # class IosCompiler
+end # module Cuesmash

data/lib/cuesmash/setup.rb

@@ -28,6 +28,7 @@ module Cuesmash
 
       # TODO: the git checkouts needs to check to see if the dirs have already been
       # checked out.
+      # TODO: (JM) turns out that appium needs to have `brew install ant` run before it will work for android
 
       private
 

data/lib/cuesmash/start.rb

@@ -3,7 +3,11 @@
 
 require 'thor'
 require 'cuesmash'
-require 'cuesmash/setup'
+require 'cuesmash/ioscompiler'
+require 'cuesmash/androidapp'
+require 'cuesmash/androidcompiler'
+require 'cuesmash/android_command'
+require 'byebug'
 
 module Cuesmash
 
@@ -22,14 +26,16 @@ module Cuesmash
       --tags -t the tags to pass to cucumber, for multiple tags pass one per tag. See cucumber tags for more info. https://github.com/cucumber/cucumber/wiki/Tags\n
       --output -o The output directory for the test report --not yet implemented--\n
       --format -f The format of the test report --not yet implemented--\n
-      --scheme -s the Xcode scheme to build\n
+      --scheme -s iOS only: the Xcode scheme to build\n
+      --app_name -n Android only: the name of the app\n
       --debug -d BOOLEAN turn on debug output\n
       --travis_ci -c BOOLEAN turn on settings for building on Travis CI\n
       --server -r BOOLEAN start up server (requires sinatra app in the project directory)\n
       --profile -p which cucumber.yml profile to use\n
       --quiet -q BOOLEAN cucumber quiet mode
     LONGDESC
-    method_option :scheme, type: :string, aliases: "-s", desc: "the Xcode scheme to build"
+    method_option :scheme, type: :string, aliases: "-s", desc: "iOS only: the Xcode scheme to build"
+    method_option :app_name, type: :string, aliases: "-n", desc: "Android only: the name of the app"
     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 :travis_ci, type: :boolean, default: false, aliases: "-c", desc: "turn on settings for building on Travis CI"
@@ -39,59 +45,91 @@ module Cuesmash
     def test
 
       # get the cuesmash.yml config
-      config = load_config
-
-      # Create new IosApp object
-      app = IosApp.new(file_name: options[:scheme], travis_build: options[:travis_ci])
+      @config = load_config
 
       # Compile the project
-      compiler = Cuesmash::Compiler.new(options[:scheme], app.tmp_dir)
-      compiler.compile
-
-      # enumerate over each device / OS combination and run the tests.
-      config['devices'].each do |device, oses|
-        oses.each do |os|
-          say "\n============================\ntesting iOS #{os} on #{device}", :green
-          Cuesmash::Command.execute(device: device, os: os, server: options[:server], tags: options[:tags], scheme: options[:scheme], travis: options[:travis_ci], debug: options[:debug], app: app, profile: options[:profile], quiet: options[:quiet])
-        end
-      end # device each
-
-      # clean up the temp dir
-      unless options[:travis_ci]
-        # clean up temp dir
+      if @config['platform'] == 'iOS'
+
+        # Create new IosApp object
+        @app = IosApp.new(file_name: options[:scheme], build_configuration: @config['build_configuration'])
+
+        setup_ios
+
+        # enumerate over each device / OS combination and run the tests.
+        @config['devices'].each do |device, oses|
+          oses.each do |os|
+            say "\n============================\ntesting iOS #{os} on #{device}", :green
+            Cuesmash::Command.execute(device: device, 
+                                      os: os, 
+                                      server: options[:server], 
+                                      tags: options[:tags], 
+                                      scheme: options[:scheme],
+                                      debug: options[:debug], 
+                                      app: @app, 
+                                      profile: options[:profile], 
+                                      quiet: options[:quiet],
+                                      timeout: @config['default']['test_timeout'].to_s)
+          end
+        end # device each
+
+        # clean up the temp dir
         Logger.info "Cleaning up tmp dir\n"
-        FileUtils.remove_entry app.tmp_dir
+        FileUtils.remove_entry @app.tmp_dir
+      
+      elsif @config['platform'] == 'Android'
+      
+        say "Setting up android", :red
+
+        @app = Cuesmash::AndroidApp.new(project_name: options[:app_name], build_configuration: @config['build_configuration'])
+        setup_android
+
+        # enumerate over each device / OS combination and run the tests.
+        @config['devices']['emulators'].each do |emulator|
+          say "\n============================\ntesting Android on #{emulator}", :green
+          Cuesmash::AndroidCommand.execute( avd: emulator,
+                                            server: options[:server], 
+                                            tags: options[:tags],
+                                            debug: options[:debug],
+                                            app: @app, 
+                                            profile: options[:profile], 
+                                            quiet: options[:quiet], 
+                                            timeout: @config['default']['test_timeout'].to_s)
+        end # device each
+      else
+        say "please set platform: 'iOS' or 'Android' in your .cuesmash.yml file", :red
+        return
       end
     end # test
 
     desc "build OPTIONS", "compile the app and create appium.txt to use for arc"
     long_desc <<-LONGDESC
-      --scheme -s the Xcode scheme to build\n
+      --scheme -s iOS: the Xcode scheme to build\n
+      --app_name -n Android: the app name
     LONGDESC
     method_option :scheme, type: :string, aliases: "-s", desc: "the Xcode scheme to build"
+    method_option :app_name, type: :string, aliases: "-n", desc: "Android only: the name of the app"
     def build
 
       # get the cuesmash.yml config
-      config = load_config
+      @config = load_config
 
       # if no default then bail
-      if config['default'] == nil
+      if @config['default'] == nil
         say "add a default device and os version to the .cuesmash.yml", :red
         return
       end
 
-      # Create new IosApp object
-      app = IosApp.new(file_name: options[:scheme], build_configuration: config['build_configuration'])
-
-      # Compile the project
-      compiler = Cuesmash::Compiler.new(options[:scheme], app.tmp_dir, config['build_configuration'])
-      compiler.compile
-
-      # create the appium text file
-      appium = AppiumText.new(platform_name: "iOS", device_name: config['default']['os'], platform_version: config['default']['version'].to_s, app: app.app_path)
-      appium.execute
+      if @config['platform'] == 'iOS'
+        setup_ios
+      elsif @config['platform'] == 'Android'
+        say "Setting up android"
+        setup_android
+      else
+        say "please set platform: 'iOS' or 'Android' in your .cuesmash.yml file", :red
+        return
+      end
 
-      say "\nYour build is available at #{app.app_path}", :green
+      say "\nYour build is available at #{@app.app_path}", :green
     end # build
 
     no_commands do
@@ -109,6 +147,55 @@ module Cuesmash
         end
         config
       end # end load_config
+
+      #
+      # helper methods
+      # 
+      def setup_ios
+        @app = IosApp.new(file_name: options[:scheme], build_configuration: @config['build_configuration'])
+
+        # Compile the project
+        compiler = Cuesmash::IosCompiler.new(options[:scheme], @app.tmp_dir, @config['build_configuration'])
+        compiler.compile
+
+        ios_appium_text
+      end
+
+      # 
+      # helper method for setting up android build
+      # 
+      def setup_android
+        @app = Cuesmash::AndroidApp.new(project_name: options[:app_name], build_configuration: @config['build_configuration'])
+
+        # Compile the project
+        compiler = Cuesmash::AndroidCompiler.new
+        compiler.compile
+
+        android_appium_text
+      end
+
+      #
+      # iOS Appium text file set up
+      # 
+      def ios_appium_text
+        appium = Cuesmash::AppiumText.new(platform_name: "iOS", 
+                                          device_name: @config['default']['os'], 
+                                          platform_version: @config['default']['version'].to_s, 
+                                          app: @app.app_path, 
+                                          new_command_timeout: @config['default']['test_timeout'].to_s)
+        appium.execute
+      end
+
+      #
+      # Android Appium text file set up
+      # 
+      def android_appium_text
+        appium = Cuesmash::AndroidAppiumText.new( platform_name: @config['platform'],
+                                                  avd: @config['default_emulator'],
+                                                  app: @app.app_path, 
+                                                  new_command_timeout: @config['default']['test_timeout'].to_s)
+        appium.execute
+      end
     end # no_commands
   end # Start class
 end # module Cuesmash

data/spec/android_compiler_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'cuesmash/android_compiler'
+
+describe Cuesmash::AndroidCompiler do
+
+  before(:each) do
+    Cuesmash::AndroidCompiler.any_instance.stub(:puts)
+  end
+
+  describe "when generating the command" do
+
+    before(:each) do
+      @compiler = Cuesmash::AndroidCompiler.new
+    end
+
+  end # "when generating the command"
+
+  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::AndroidCompiler.new
+    end # before
+
+    it "should complete if all is well" do
+      @value.stub(:exitstatus){0}
+      @compiler.compile do |complete|
+        expect(complete).to equal(true)
+      end
+    end # "should complete if all is well" 
+  end # "when compiling"
+end # describe Cuesmash::AndroidCompiler

data/spec/appium_text_spec.rb

@@ -4,9 +4,11 @@ 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")
+      @appiumtext = Cuesmash::AppiumText.new(platform_name: "iOS", device_name: "iPhone Simulator", platform_version: "7.1", app: "MyApp", new_command_timeout: "90")
     end
 
+    expected = "[caps]\nplatformName = \"iOS\"\ndeviceName = \"iPhone Simulator\"\nplatformVersion = \"7.1\"\napp = \"MyApp\"\nnewCommandTimeout = \"90\"\n"
+
     it "should have a platform name" do
       expect(@appiumtext.platform_name).to match("iOS")
     end
@@ -22,5 +24,24 @@ describe Cuesmash::AppiumText do
     it "should have an app name" do
       expect(@appiumtext.app).to match("MyApp")
     end
+
+    it "should have an newCommandTimeout" do
+      expect(@appiumtext.new_command_timeout).to match("90")
+    end
+
+    it "should output this text" do
+      # TODO: we need to test that the text output is actually right. I'm putting this off until next week though.
+      # # IO.expects(:write).with("features/support/appium.txt", expected).once
+      # expect(IO).to recieve(:write).with("features/support/appium.txt", expected)
+
+      # @appiumtext.execute
+      # # expect(@appiumtext.appium_text_for_file).to match(expected)
+      # # 
+      # # 
+      # # expect(logger).to receive(:account_closed).with(account)
+
+      # # account.close
+    end
+
   end
 end

data/spec/command_spec.rb

@@ -55,14 +55,9 @@ describe Cuesmash::Command do
         Cuesmash::Cucumber.stub(:new){@mock}
       end
 
-      it "should set the cucumber ios version" do
-        Cuesmash::Cucumber.should_receive(:new).with("ios", anything, anything, anything)
-        Cuesmash::Command.run_tests(ios: "ios", tags: "tags", profile: "profile", quiet: true)
-      end
-
       it "should set the cucumber tags" do
-        Cuesmash::Cucumber.should_receive(:new).with(anything, "tags", anything, anything)
-        Cuesmash::Command.run_tests(ios: "ios", tags: "tags", profile: "profile", quiet: true)
+        Cuesmash::Cucumber.should_receive(:new).with("tags", anything, anything)
+        Cuesmash::Command.run_tests(tags: "tags", profile: "profile", quiet: true)
       end
 
       it "should set the format" do
@@ -70,7 +65,7 @@ describe Cuesmash::Command do
         Cuesmash::Cucumber.stub(:new){@cucumber}
 
         @cucumber.should_receive(:format=)
-        Cuesmash::Command.run_tests(ios: nil, tags: nil, profile: nil, format: "format", quiet: anything)
+        Cuesmash::Command.run_tests(tags: nil, profile: nil, format: "format", quiet: anything)
       end
 
       it "should set the output" do
@@ -78,12 +73,12 @@ describe Cuesmash::Command do
         Cuesmash::Cucumber.stub(:new){@cucumber}
 
         @cucumber.should_receive(:output=)
-        Cuesmash::Command.run_tests(ios: nil, tags: nil, profile: nil, format: nil, output: "output", quiet: anything)
+        Cuesmash::Command.run_tests(tags: nil, profile: nil, format: nil, output: "output", quiet: anything)
       end
 
       it "should start the tests" do
         @mock.should_receive(:test)
-        Cuesmash::Command.run_tests(ios: "ios", tags: "tags", profile: "profile", quiet: true)
+        Cuesmash::Command.run_tests(tags: "tags", profile: "profile", quiet: true)
       end
 
     end # describe "when running the cucumber tests"

data/spec/cucumber_spec.rb

@@ -15,7 +15,7 @@ describe Cuesmash::Cucumber do
       wait.stub(:join)
       Open3.stub(:popen3).and_yield(nil, nil, nil, wait)
 
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
       @cucumber.stub(:command)
     end
 
@@ -29,75 +29,75 @@ describe Cuesmash::Cucumber do
   describe "when generating the command" do
 
     it "should not add the ios version if missing" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
       @cucumber.stub(:tag_arguments)
 
       expect(@cucumber.instance_eval{command}).not_to match(/DEVICE_TARGET/)
     end
 
     it "should add the format" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
       @cucumber.format = "test-format"
 
       expect(@cucumber.instance_eval{command}).to match(/--format test-format/)
     end
 
     it "should not add the format if missing" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
 
       expect(@cucumber.instance_eval{command}).not_to match(/--format/)
     end
 
     it "should add the output" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
       @cucumber.output = "test-output"
 
       expect(@cucumber.instance_eval{command}).to match(/--out test-output/)
     end
 
     it "should not add the output if missing" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
 
       expect(@cucumber.instance_eval{command}).not_to match(/--out/)
     end
 
     it "should add the tags" do
-      @cucumber = Cuesmash::Cucumber.new(nil, ["tag1", "tag2"], nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(["tag1", "tag2"], nil, nil)
       expect(@cucumber.instance_eval{command}).to match(/--tags tag1 --tags tag2/)
     end
 
     it "should not add tags if missing" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
       expect(@cucumber.instance_eval{command}).not_to match(/--tags/)
     end
 
     it "should add the profile" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, "test", nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, "test", nil)
       expect(@cucumber.instance_eval{command}).to match(/--profile test/)
     end
 
     it "should not add tags if missing" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
       expect(@cucumber.instance_eval{command}).not_to match(/--profile/)
     end
 
     it "should add the color flag" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
       expect(@cucumber.instance_eval{command}).to match(/-c/)
     end
 
     it "should not add quiet if missing" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, nil)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil)
       expect(@cucumber.instance_eval{command}).not_to match(/--quiet/)
     end
 
     it "should not add quiet if false" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, false)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, false)
       expect(@cucumber.instance_eval{command}).not_to match(/--quiet/)
     end
 
     it "should add the quiet flag" do
-      @cucumber = Cuesmash::Cucumber.new(nil, nil, nil, true)
+      @cucumber = Cuesmash::Cucumber.new(nil, nil, true)
       expect(@cucumber.instance_eval{command}).to match(/--quiet/)
     end
 

data/spec/ios_app_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'cuesmash/ios_app'
+require 'cuesmash/app'
+
+describe Cuesmash::IosApp do
+  describe "when creating a new instance" do
+
+    it "should have an app_dir instance" do
+      stub_dir
+      @iosapp = Cuesmash::IosApp.new(file_name: "MyApp", build_configuration: "Debug")
+      expect(@iosapp.app_dir).to match("/tmp/Debug-iphonesimulator/")
+    end
+
+    it "should have an app_path instance" do
+      stub_dir
+      @iosapp = Cuesmash::IosApp.new(file_name: "MyApp", build_configuration: "Debug")
+      expect(@iosapp.app_path).to match("/tmp/Debug-iphonesimulator/MyApp.app")
+    end
+
+    it "should have a tmp_dir instance" do
+      stub_dir
+      @iosapp = Cuesmash::IosApp.new(file_name: "MyApp", build_configuration: "Debug")
+      expect(@iosapp.tmp_dir).to match("/tmp")
+    end
+
+    it "should have an app_name instance" do
+
+      @iosapp = Cuesmash::IosApp.new(file_name: "MyApp", build_configuration: "Debug")
+      expect(@iosapp.app_name).to match("MyApp.app")
+    end
+
+    def stub_dir
+      Dir.stub(:mktmpdir) { "/tmp" }
+    end
+  end
+end

data/spec/ios_compiler_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'cuesmash/ios_compiler'
+
+describe Cuesmash::IosCompiler do
+
+  before(:each) do
+    Cuesmash::IosCompiler.any_instance.stub(:puts)
+  end
+
+  it "should have a scheme instance" do
+    compiler = Cuesmash::IosCompiler.new("scheme", "/tmp", "Debug")
+    expect(compiler.scheme).to match("scheme")
+  end
+
+  it "should have a tmp_dir instance" do
+    compiler = Cuesmash::IosCompiler.new("scheme", "/tmp", "Debug")
+    expect(compiler.tmp_dir).to match("/tmp")
+  end
+
+  it "should have a build config" do
+    compiler = Cuesmash::IosCompiler.new("scheme", "/tmp", "Debug")
+    expect(compiler.build_configuration).to match("Debug")
+  end
+
+  describe "when generating the command" do
+
+    before(:each) do
+      Cuesmash::IosCompiler.any_instance.stub(:workspace)
+      @compiler = Cuesmash::IosCompiler.new("test-scheme", "/tmp", "Debug")
+    end
+
+    it "should contain the scheme" do
+      expect(@compiler.instance_eval{command}).to match(/test-scheme/)
+    end
+
+    it "should contain the tmp path" do
+      expect(@compiler.instance_eval{command}).to match(/tmp/)
+    end
+
+    it "should contain the build configuration" do
+      expect(@compiler.instance_eval{command}).to match(/Debug/)
+    end
+  end
+
+  describe "when getting the workspacae" do
+
+    before(:each) do
+      @compiler = Cuesmash::IosCompiler.new(nil, "/tmp", "Debug")
+      Dir.stub(:[]){["workspace-file"]}
+    end
+
+    it "should get the workspace from the current directory" do
+      expect(@compiler.instance_eval{workspace}).to 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::IosCompiler.new(nil, "/tmp", "Debug")
+    end
+
+    it "should complete if all is well" do
+      @value.stub(:exitstatus){0}
+      @compiler.compile do |complete|
+        expect(complete).to equal(true)
+      end
+    end
+  end
+end