parallel_appium 0.2.0

data/README.md

@@ -0,0 +1,41 @@
+# parallel_appium
+
+Distributed mobile testing in Appium
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'parallel_appium'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install parallel_appium
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/JavonDavis/parallel_appium. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html).
+
+## Code of Conduct
+
+Everyone interacting in the ParallelAppium project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/JavonDavis/parallel_appium/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/apps/.gitignore

@@ -0,0 +1,3 @@
+# Created by .ignore support plugin (hsz.mobi)
+*.apk
+*.app

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'parallel_appium'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/certs/javondavis.pem

@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEhTCCAu2gAwIBAgIBATANBgkqhkiG9w0BAQsFADBEMRYwFAYDVQQDDA1qYXZv
+bmxkYXZpczE0MRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZ
+FgNjb20wHhcNMTgwNjA2MTcxNjM2WhcNMTkwNjA2MTcxNjM2WjBEMRYwFAYDVQQD
+DA1qYXZvbmxkYXZpczE0MRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJ
+k/IsZAEZFgNjb20wggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDCwCJw
+CoVPoQgQSDGGGRWyt40oMNZHFc85AiRjBU7UMFgYSPQIt0M+SCyJaptM0pJYGG65
+M/hx4Hnqw93ELvPWtAAHgP/9u05K3uiWgsxFRHm5S9JxMS/nvNRatVYvy2hKQGTU
+zJpczncAhu0Lj9tlCuZMdvnhh9PAInrNaXQMkkk4n/XV9dk3lhyqemMFyKJhS0dO
+k3JTn3muVdSOdLMOGJtreHdV5TByA/rIYQGraIqHrlbAbnGOnNunMk53M9eI3zAq
+gz8fydEkaHswv7Mbk3kWnN67UMaNUpoElnEEj0242BtXhXeXr9FnqcFLwUrQLXKK
+kc2BjV1CbK7AHMKLfU2yBQJVqEkb+Xu8dAkpHP333adf7KEW8N0vf+639jgBPbxa
+y25Sh4ZQAuue1NVl43Uj7Qkbb2V4epiNr1JhRrpvMSQah2lx9yNs/NtgdZWHtidd
++3chmKUroK4elci3NKa76G+iwbD/pJkWg0zFt4cg4+pgWdmjX3PLnd0iv2UCAwEA
+AaOBgTB/MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBSjN7L+WZRc
+/FBz01MZd7lsGI5j7jAiBgNVHREEGzAZgRdqYXZvbmxkYXZpczE0QGdtYWlsLmNv
+bTAiBgNVHRIEGzAZgRdqYXZvbmxkYXZpczE0QGdtYWlsLmNvbTANBgkqhkiG9w0B
+AQsFAAOCAYEAoxRokaBO+VS8xqmPtqEKofcXF2kJDemn9Jn9Begjj7mzqUVHOR9w
+4HHaAY79m1xm+yiveWgOsHvb04GCjR32dJjAcbb7dsg3aXOd49UoQ0lOVtOigH2s
+v5BqR5svvPKoDA8nP0V9pTOxFboJw5dtY+s95Py6mc6nTsK3XdCUS80PiY3xPWS+
+pCzJWE1mNMhRndpb9E0BAiimdmo3suQo7EVYQ3tPsnHwaSdv52tt9kW+rpoHFRV5
+gjyXjRGX/lW897Zs2AA7yFb7oVvbaAlGyH2MLVnB5aiTywqE0ZgD9CTgSnGYu0iY
+28Uiprdx/AqGsAVNV8YAsPMEm/81xTXmJ0HRrpyvMHyAXuNPp84t4TsO2DQtAlrU
+XuXlmerWWuxSKZOwV9fJfl+j5fO7bzUyeWK76xvvWGNtIF19xPnGdPpupaClWMHg
+pjBkMT4ow4ZhVgBKPDT2jh74b8g2rIDSbkJIj0lf35WXqJqZzseabGPpTbtzJEap
+HIrd7mPILLe3
+-----END CERTIFICATE-----

data/docs/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

data/exe/parallel_appium

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'parallel_appium'
+ParallelAppium::ParallelAppium.new.start platform:ARGV[0]

data/lib/parallel_appium/android.rb

@@ -0,0 +1,35 @@
+module ParallelAppium
+  # Connecting to Android devices
+  class Android
+    # Fire up the Android emulators
+    def start_emulators
+      emulators = `emulator -list-avds`.split("\n")
+      emulators = emulators[0, ENV['THREADS'].to_i]
+      Parallel.map(emulators, in_threads: emulators.size) do |emulator|
+        spawn("emulator -avd #{emulator} -scale 100dpi -no-boot-anim -no-audio -accel on &", out: '/dev/null')
+      end
+    end
+
+    # Get additional information for the Android device with unique identifier udid
+    def get_android_device_data(udid)
+      specs = { os: 'ro.build.version.release', manufacturer: 'ro.product.manufacturer', model: 'ro.product.model', sdk: 'ro.build.version.sdk' }
+      hash = {}
+      specs.each do |key, spec|
+        value = `adb -s #{udid} shell getprop "#{spec}"`.strip
+        hash.merge!(key => value.to_s)
+      end
+      hash
+    end
+
+    # Devices after cleanup and supplemental data included
+    def devices
+      start_emulators
+      sleep 10
+      devices = `adb devices`.split("\n").select { |x| x.include? "\tdevice" }.map.each_with_index { |d, i| {platform: 'android', name: 'android', udid: d.split("\t")[0], wdaPort: 8100 + i, thread: i + 1} }
+      devices = devices.map { |x| x.merge(get_android_device_data(x[:udid])) }
+
+      ENV['DEVICES'] = JSON.generate(devices)
+      devices
+    end
+  end
+end

data/lib/parallel_appium/ios.rb

@@ -0,0 +1,30 @@
+module ParallelAppium
+  # Connecting to iOS devices
+  class IOS
+
+    def initialize
+      # Get available simulators
+      @simulators = `instruments -s devices`.split("\n").reverse
+    end
+
+    # Filter simulator data
+    def simulator_information
+      re = /\([0-9]+\.[0-9]\) \[[0-9A-Z-]+\]/m
+
+      # Filter out simulator info for iPhone platform version and udid
+      @simulators.select { |simulator_data| simulator_data.include?('iPhone') && !simulator_data.include?('Apple Watch') }
+                 .map { |simulator_data| simulator_data.scan(re)[0].tr('()[]', '').split }[0, ENV['THREADS'].to_i]
+    end
+
+    # Devices after cleanup and supplemental data included
+    def devices
+      devices = []
+      simulator_information.each_with_index do |data, i|
+        devices.push(name: @simulators[i][0, @simulators[i].index('(') - 1], platform: 'ios', os: data[0], udid: data[1],
+                     wdaPort: 8100 + i + ENV['THREADS'].to_i, thread: i + 1)
+      end
+      ENV['DEVICES'] = JSON.generate(devices)
+      devices
+    end
+  end
+end

data/lib/parallel_appium/server.rb

@@ -0,0 +1,164 @@
+module ParallelAppium
+  # Setting up the selenium grid server
+  class Server
+    # Sets the current thread number environment variable(TEST_ENV_NUMBER)
+    def thread
+      (ENV['TEST_ENV_NUMBER'].nil? || ENV['TEST_ENV_NUMBER'].empty? ? 1 : ENV['TEST_ENV_NUMBER']).to_i
+    end
+
+    # Get the device data from the DEVICES environment variable
+    def device_data
+      JSON.parse(ENV['DEVICES']).find { |t| t['thread'].eql? thread } unless ENV['DEVICES'].nil?
+    end
+
+    # Save device specifications to output directory
+    def save_device_data(dev_array)
+      dev_array.each do |device|
+        device_hash = {}
+        device.each do |key, value|
+          device_hash[key] = value
+        end
+
+        # Delete and create output folder
+        `rm -rf output`
+        `mkdir output`
+
+        device.each do |k, v|
+          open("output/specs-#{device_hash[:udid]}.log", 'a') do |file|
+            file << "#{k}: #{v}\n"
+          end
+        end
+      end
+    end
+
+    # Set UDID and name environment variable
+    def set_udid_environment_variable
+      ENV['UDID'] = device_data['udid'] unless device_data.nil?
+      ENV['name'] = device_data['name'] unless device_data.nil? # Unique on ios but could be repeated on android
+    end
+
+    # Get the device information for the respective platform
+    def get_devices(platform)
+      ENV['THREADS'] = '1' if ENV['THREADS'].nil?
+      if platform == 'android'
+        Android.new.devices
+      elsif platform == 'ios'
+        IOS.new.devices
+      end
+    end
+
+    # Start the appium server with the specified options
+    def appium_server_start(**options)
+      command = +'appium'
+      command << " --nodeconfig #{options[:config]}" if options.key?(:config)
+      command << " -p #{options[:port]}" if options.key?(:port)
+      command << " -bp #{options[:bp]}" if options.key?(:bp)
+      command << " --log #{Dir.pwd}/output/#{options[:log]}" if options.key?(:log)
+      command << " --tmp #{ENV['BASE_DIR']}/tmp/#{options[:tmp]}" if options.key?(:tmp)
+      Dir.chdir('.') do
+        puts(command)
+        pid = spawn(command, out: '/dev/null')
+        puts 'Waiting for Appium to start up...'
+        sleep 10
+        puts "Appium PID: #{pid}"
+        puts 'Appium server did not start' if pid.nil?
+      end
+    end
+
+    # Generate node config for sellenium grid
+    def generate_node_config(file_name, appium_port, device)
+      system 'mkdir node_configs >> /dev/null 2>&1'
+      f = File.new("#{Dir.pwd}/node_configs/#{file_name}", 'w')
+      f.write(JSON.generate(
+                capabilities: [{ browserName: device[:udid], maxInstances: 5, platform: device[:platform] }],
+                configuration: { cleanUpCycle: 2000,
+                                 timeout: 1_800_000,
+                                 registerCycle: 5000,
+                                 proxy: 'org.openqa.grid.selenium.proxy.DefaultRemoteProxy',
+                                 url: "http://127.0.0.1:#{appium_port}/wd/hub",
+                                 host: '127.0.0.1',
+                                 port: appium_port,
+                                 maxSession: 5,
+                                 register: true,
+                                 hubPort: 4444,
+                                 hubHost: 'localhost' }
+      ))
+      f.close
+    end
+
+    # Start the Selenium grid server as a hub
+    def start_hub
+      spawn("java -jar #{File.dirname(__FILE__)}/selenium-server-standalone-3.12.0.jar -role hub -newSessionWaitTimeout 250000 -log #{Dir.pwd}/output/hub.log &", out: '/dev/null')
+      sleep 3 # wait for hub to start...
+      spawn('open -a safari http://127.0.0.1:4444/grid/console')
+    end
+
+    # Start an appium server or the platform on the specified port
+    def start_single_appium(platform, port)
+      puts 'Getting Device data'
+      devices = get_devices(platform)[0]
+      if devices.nil?
+        puts "No devices for #{platform}, Exiting..."
+        exit
+      else
+        udid = devices[:udid]
+        save_device_data [devices]
+      end
+      ENV['UDID'] = udid
+      appium_server_start udid: udid, log: "appium-#{udid}.log", port: port
+    end
+
+    # Check if a port on an ip address is available
+    def port_open?(ip, port)
+      begin
+        Timeout.timeout(1) do
+          begin
+            s = TCPSocket.new(ip, port)
+            s.close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return false
+          end
+        end
+      rescue Timeout::Error
+        return false
+      end
+      false
+    end
+
+    # Launch the Selenium grid hub and required appium instances
+    def launch_hub_and_nodes(platform)
+      start_hub unless port_open?('localhost', 4444)
+      devices = get_devices(platform)
+
+      if devices.nil?
+        puts "No devices for #{platform}, Exiting...."
+        exit
+      else
+        save_device_data [devices]
+      end
+
+      threads = ENV['THREADS'].to_i
+      if devices.size < threads
+        puts "Not enough available devices, reducing to #{devices.size} threads"
+        ENV['THREADS'] = devices.size.to_s
+      else
+        puts "Using #{threads} of the available #{devices.size} devices"
+        devices = devices[0, threads]
+      end
+
+
+      Parallel.map_with_index(devices, in_processes: devices.size) do |device, index|
+        offset = platform == 'android' ? 0 : threads
+        port = 4000 + index + offset
+        bp = 2250 + index + offset
+        config_name = "#{device[:udid]}.json"
+        generate_node_config config_name, port, device
+        node_config = "#{Dir.pwd}/node_configs/#{config_name}"
+        puts port
+        appium_server_start config: node_config, port: port, bp: bp, udid: device[:udid],
+                            log: "appium-#{device[:udid]}.log", tmp: device[:udid]
+      end
+    end
+  end
+end

data/lib/parallel_appium/version.rb

@@ -0,0 +1,3 @@
+module ParallelAppium
+  VERSION = '0.2.0'.freeze
+end

data/lib/parallel_appium.rb

@@ -0,0 +1,218 @@
+require 'parallel_appium/version'
+require 'parallel_appium/server'
+require 'parallel_appium/android'
+require 'parallel_appium/ios'
+require 'parallel_tests'
+require 'parallel'
+require 'appium_lib'
+require 'socket'
+require 'timeout'
+require 'json'
+
+module ParallelAppium
+  # Set up environment, Selenium and Appium
+  class ParallelAppium
+
+    def initialize
+      @server = Server.new
+    end
+
+    # Kill process by pattern name
+    def kill_process(process)
+      `ps -ef | grep #{process} | awk '{print $2}' | xargs kill -9 >> /dev/null 2>&1`
+    end
+
+    # Load capabilities based on current device data
+    def load_capabilities(caps)
+      device = @server.device_data
+      unless device.nil?
+        caps[:caps][:udid] = device.fetch('udid', nil)
+        caps[:caps][:platformVersion] = device.fetch('os', caps[:caps][:platformVersion])
+        caps[:caps][:deviceName] = device.fetch('name', caps[:caps][:deviceName])
+        caps[:caps][:wdaLocalPort] = device.fetch('wdaPort', nil)
+      end
+
+      caps[:caps][:sessionOverride] = true
+      caps[:caps][:useNewWDA] = true
+      # TODO: Optionally set these capabilities below
+      caps[:caps][:noReset] = true
+      caps[:caps][:fullReset] = false
+      caps[:appium_lib][:server_url] = ENV['SERVER_URL']
+      caps
+    end
+
+    # Load appium text file if available and attempt to start the driver
+    # platform is either android or ios, otherwise read from ENV
+    # caps is mapping of appium capabilities
+    def initialize_appium(**args)
+      platform = args[:platform]
+      caps = args[:caps]
+
+      platform = ENV['platform'] if platform.nil?
+
+      if platform.nil?
+        puts 'Platform not found in environment variable'
+        exit
+      end
+
+      caps = Appium.load_appium_txt file: File.new("#{Dir.pwd}/appium-#{platform}.txt") if caps.nil?
+
+      if caps.nil?
+        puts 'No capabilities specified'
+        exit
+      end
+      capabilities = load_capabilities(caps)
+      @driver = Appium::Driver.new(capabilities, true)
+      @driver.start_driver
+      Appium.promote_appium_methods Object
+      Appium.promote_appium_methods RSpec::Core::ExampleGroup
+      @driver
+    end
+
+    # Define a signal handler for SIGINT
+    def setup_signal_handler(ios_pid = nil, android_pid = nil)
+      Signal.trap('INT') do
+        Process.kill('INT', ios_pid) unless ios_pid.nil?
+        Process.kill('INT', android_pid) unless android_pid.nil?
+
+        # Kill any existing Appium and Selenium processes
+        kill_process 'appium'
+        kill_process 'selenium'
+
+        # Terminate ourself
+        exit 1
+      end
+    end
+
+    # Decide whether to execute specs in parallel or not
+    # @param [String] platform
+    # @param [int] threads
+    # @param [String] spec_path
+    # @param [boolean] parallel
+    def execute_specs(platform, threads, spec_path, parallel = false)
+      command = if parallel
+                  "platform=#{platform} parallel_rspec -n #{threads} #{spec_path}  > output/#{platform}.log"
+                else
+                  "platform=#{platform} rspec #{spec_path} --tag #{platform} > output/#{platform}.log"
+                end
+
+      puts "Executing #{command}"
+      exec command
+    end
+
+    # Define Spec path, validate platform and execute specs
+    def setup(platform, file_path, threads, parallel)
+      spec_path = 'spec/'
+      spec_path = file_path.to_s unless file_path.nil?
+      puts "SPEC PATH:#{spec_path}"
+
+      unless %w[ios android].include? platform
+        puts "Invalid platform #{platform}"
+        exit
+      end
+
+      execute_specs platform, threads, spec_path, parallel
+    end
+
+    # Validate platform is valid
+    def check_platform(platform)
+      options = %w[ios android all]
+      if platform.nil?
+        puts 'No platform detected... Options: ios,android,all'
+        exit
+      elsif !options.include? platform.downcase
+        puts "Invalid platform #{platform}"
+        exit
+      end
+    end
+
+    # Fire necessary appium server instances and Selenium grid server if needed.
+    def start(**args)
+
+      platform = args[:platform]
+      file_path = args[:file_path]
+
+      # Validate environment variable
+      if ENV['platform'].nil?
+        if platform.nil?
+          puts 'No platform detected in environment and none passed to start...'
+          exit
+        end
+        ENV['platform'] = platform
+      end
+
+      sleep 3
+
+      # Appium ports
+      ios_port = 4725
+      android_port = 4727
+      default_port = 4725
+
+      platform = ENV['platform']
+
+      # Platform is required
+      check_platform platform
+
+      platform = platform.downcase
+      ENV['BASE_DIR'] = Dir.pwd
+
+      # Check if multithreaded for distributing tests across devices
+      threads = ENV['THREADS'].nil? ? 1 : ENV['THREADS'].to_i
+      parallel = threads != 1
+
+      if platform != 'all'
+        pid = fork do
+          if !parallel
+            ENV['SERVER_URL'] = "http://0.0.0.0:#{default_port}/wd/hub"
+            @server.start_single_appium platform, default_port
+          else
+            ENV['SERVER_URL'] = 'http://localhost:4444/wd/hub'
+            @server.launch_hub_and_nodes platform
+          end
+          setup(platform, file_path, threads, parallel)
+        end
+
+        puts "PID: #{pid}"
+        setup_signal_handler(pid)
+        Process.waitpid(pid)
+      else # Spin off 2 sub-processes, one for Android connections and another for iOS,
+        # each with redefining environment variables for the server url, number of threads and platform
+        ios_pid = fork do
+          ENV['THREADS'] = threads.to_s
+          if parallel
+            ENV['SERVER_URL'] = 'http://localhost:4444/wd/hub'
+            puts 'Start iOS'
+            @server.launch_hub_and_nodes 'ios'
+          else
+            ENV['SERVER_URL'] = "http://0.0.0.0:#{ios_port}/wd/hub"
+            puts 'Start iOS'
+            @server.start_single_appium 'ios', ios_port
+          end
+          setup('ios', file_path, threads, parallel)
+        end
+
+        android_pid = fork do
+          ENV['THREADS'] = threads.to_s
+          if parallel
+            ENV['SERVER_URL'] = 'http://localhost:4444/wd/hub'
+            puts 'Start Android'
+            @server.launch_hub_and_nodes 'android'
+          else
+            ENV['SERVER_URL'] = "http://0.0.0.0:#{android_port}/wd/hub"
+            puts 'Start Android'
+            @server.start_single_appium 'android', android_port
+          end
+          setup('android', file_path, threads, parallel)
+        end
+
+        puts "iOS PID: #{ios_pid}\nAndroid PID: #{android_pid}"
+        setup_signal_handler(ios_pid, android_pid)
+        [ios_pid, android_pid].each { |process_pid| Process.waitpid(process_pid) }
+      end
+
+      # Kill any existing Appium and Selenium processes
+      kill_process 'appium'
+      kill_process 'selenium'
+    end
+  end
+end

data/parallel_appium.gemspec

@@ -0,0 +1,52 @@
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'parallel_appium/version'
+
+summary = 'Start multi-threaded appium servers'
+description = 'Through the creation of multiple environments
+ this library allows for the distribution of multiple tests across 1 or more
+devices or simulators. The library uses Selenium Grid and Appium to launch a
+specified number of web driver and appium instances to spread the test load
+across available devices'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'parallel_appium'
+  spec.version       = ParallelAppium::VERSION
+  spec.authors       = ['Javon Davis']
+  spec.email         = ['javonldavis14@gmail.com']
+
+  spec.summary       = summary
+  spec.description   = description
+  spec.homepage      = 'https://github.com/JavonDavis/Parallel_Appium'
+  spec.license       = 'GPL-3.0'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "http://mygemserver.com"
+  # else
+  #   raise 'RubyGems 2.4.1 or newer is required to protect against ' \
+  #     'public gem pushes.'
+  # end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.cert_chain  = ['certs/javondavis.pem']
+  spec.signing_key = File.expand_path('~/.ssh/gem-private_key.pem') if $PROGRAM_NAME =~ /gem\z/
+
+  spec.add_development_dependency 'appium_lib', '~> 9.14'
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'json', '~> 1.8'
+  spec.add_development_dependency 'parallel', '~> 1.12'
+  spec.add_development_dependency 'parallel_tests', '~> 2.21'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end