datadog-sdk-testing 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c74227db510a81eea5631e7c0662c75877555dc3
+  data.tar.gz: ae7bd7b68c6ad64cc41b09d587495ae3be1a26c0
+SHA512:
+  metadata.gz: 174b4496355eef80152159b344a655476e78cf6207018b0ea0aa9c49e1360afcf9709833bdb3bc43daab35e59dd76f0474aff1be3df0b1f950b34b92b3a7c947
+  data.tar.gz: 3bd3194d905f302cb0609ee35fc0c47e1c1df2db1429376b0c335bf713607b0fd7d60d22e6a61df2c14fedcfa7a27bec4072d1bd90b8d371504def0b0a86057f

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2015, Datadog <info@datadoghq.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Datadog nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,30 @@
+# datadog-sdk-testing
+Gem repo providing Integration SDK testing/scaffolding facilities (unpublished).
+
+## usage
+This gem essentially just provides a set of rake tasks to help you get up and running with integration testing and scaffolding. We expect to use this gem in `integrations-core` and `integrations-extras`.
+
+To use the tasks in this gem just add a Rakefile to the relevant project with these contents:
+
+```
+#!/usr/bin/env rake
+
+require 'rake'
+
+unless ENV['CI']
+  rakefile_dir = File.dirname(__FILE__)
+  ENV['TRAVIS_BUILD_DIR'] = rakefile_dir
+  ENV['INTEGRATIONS_DIR'] = File.join(rakefile_dir, 'embedded')
+  ENV['PIP_CACHE'] = File.join(rakefile_dir, '.cache/pip')
+  ENV['VOLATILE_DIR'] = '/tmp/integration-sdk-testing'
+  ENV['CONCURRENCY'] = ENV['CONCURRENCY'] || '2'
+  ENV['NOSE_FILTER'] = 'not windows'
+  ENV['RUN_VENV'] = 'true'
+  ENV['SDK_TESTING'] = 'true'
+end
+
+ENV['SDK_HOME'] = File.dirname(__FILE__)
+
+spec = Gem::Specification.find_by_name 'datadog-sdk-testing'
+load "#{spec.gem_dir}/lib/tasks/sdk.rake"
+```

data/lib/config/README.md

@@ -0,0 +1,32 @@
+# Skeleton Integration
+
+## Overview
+
+Get metrics from skeleton service in real time to:
+
+* Visualize and monitor skeleton states
+* Be notified about skeleton failovers and events.
+
+## Installation
+
+Install the `dd-check-skeleton` package manually or with your favorite configuration manager
+
+## Configuration
+
+Edit the `skeleton.yaml` file to point to your server and port, set the masters to monitor
+
+## Validation
+
+When you run `datadog-agent info` you should see something like the following:
+
+    Checks
+    ======
+
+        skeleton
+        -----------
+          - instance #0 [OK]
+          - Collected 39 metrics, 0 events & 7 service checks
+
+## Compatibility
+
+The skeleton check is compatible with all major platforms

data/lib/config/check.py

@@ -0,0 +1,17 @@
+# stdlib
+
+# 3rd party
+
+# project
+from checks import AgentCheck
+
+EVENT_TYPE = SOURCE_TYPE_NAME = 'skeleton'
+
+
+class SkeletonCheck(AgentCheck):
+
+    def __init__(self, name, init_config, agentConfig, instances=None):
+        AgentCheck.__init__(self, name, init_config, agentConfig, instances)
+
+    def check(self, instance):
+        pass

data/lib/config/ci/skeleton.rake

@@ -0,0 +1,69 @@
+require 'ci/common'
+
+def skeleton_version
+  ENV['FLAVOR_VERSION'] || '2.4.12'
+end
+
+def skeleton_rootdir
+  "#{ENV['INTEGRATIONS_DIR']}/skeleton_#{skeleton_version}"
+end
+
+namespace :ci do
+  namespace :skeleton do |flavor|
+    task before_install: ['ci:common:before_install']
+
+    task install: ['ci:common:install'] do
+      use_venv = in_venv
+      install_requirements('skeleton/requirements.txt',
+                           "--cache-dir #{ENV['PIP_CACHE']}",
+                           "#{ENV['VOLATILE_DIR']}/ci.log", use_venv)
+      # sample docker usage
+      # sh %(docker create -p XXX:YYY --name skeleton source/skeleton)
+      # sh %(docker start skeleton)
+    end
+
+    task before_script: ['ci:common:before_script']
+
+    task :script, [:mocked] => ['ci:common:script'] do |_, attr|
+      ci_home = File.dirname(__FILE__)
+      mocked = attr[:mocked] || false
+      this_provides = [
+        'skeleton'
+      ]
+      Rake::Task['ci:common:run_tests'].invoke(this_provides, ci_home, mocked)
+    end
+
+    task before_cache: ['ci:common:before_cache']
+
+    task cleanup: ['ci:common:cleanup']
+    # sample cleanup task
+    # task cleanup: ['ci:common:cleanup'] do 
+    #   sh %(docker stop skeleton)
+    #   sh %(docker rm skeleton)
+    # end
+
+    task :execute, :mocked do |_, attr|
+      mocked = attr[:mocked] || false
+      exception = nil
+      begin
+        if not mocked
+          %w(before_install install before_script).each do |u|
+            Rake::Task["#{flavor.scope.path}:#{u}"].invoke
+          end
+        end
+        Rake::Task["#{flavor.scope.path}:script"].invoke(mocked)
+        Rake::Task["#{flavor.scope.path}:before_cache"].invoke
+      rescue => e
+        exception = e
+        puts "Failed task: #{e.class} #{e.message}".red
+      end
+      if ENV['SKIP_CLEANUP']
+        puts 'Skipping cleanup, disposable environments are great'.yellow
+      else
+        puts 'Cleaning up'
+        Rake::Task["#{flavor.scope.path}:cleanup"].invoke
+      end
+      raise exception if exception
+    end
+  end
+end

data/lib/config/conf.yaml.example

@@ -0,0 +1,6 @@
+init_config:
+
+instances:
+  - host: localhost
+    port: 26379
+    tags: ['custom:tag']

data/lib/config/manifest.json

@@ -0,0 +1,10 @@
+{
+  "maintainer": "help@datadoghq.com",
+  "manifest_version": "0.1.0",
+  "max_agent_version": "6.0.0",
+  "min_agent_version": "5.6.3",
+  "name": "skeleton",
+  "short_description": "skeleton description.",
+  "support": "contrib",
+  "version": "0.1.0"
+}

data/lib/config/requirements.txt

@@ -0,0 +1 @@
+# integration pip requirements

data/lib/config/test_skeleton.py

@@ -0,0 +1,34 @@
+# stdlib
+from nose.plugins.attrib import attr
+
+# 3p
+
+# project
+from tests.checks.common import AgentCheckTest
+
+
+instance = {
+    'host': 'localhost',
+    'port': 26379,
+    'password': 'datadog-is-devops-best-friend'
+}
+
+
+# NOTE: Feel free to declare multiple test classes if needed
+
+@attr(requires='skeleton', mock=False)  # set mock to True if appropriate
+class TestSkeleton(AgentCheckTest):
+    """Basic Test for skeleton integration."""
+    CHECK_NAME = 'skeleton'
+
+    def test_check(self):
+        """
+        Testing Skeleton check.
+        """
+        self.load_check({}, {})
+
+        # run your actual tests...
+
+        self.assertTrue(True)
+        # Raises when COVERAGE=true and coverage < 100%
+        self.coverage_report()

data/lib/tasks/ci/common.rb

@@ -0,0 +1,215 @@
+require 'colorize'
+require 'httparty'
+require 'socket'
+require 'time'
+require 'timeout'
+
+# Colors don't work on Appveyor
+String.disable_colorization = true if Gem.win_platform?
+
+
+def check_env
+  abort 'SDK_HOME env variable must be defined in your Rakefile to used this gem.' unless ENV['SDK_HOME']
+end
+
+def sleep_for(secs)
+  puts "Sleeping for #{secs}s".blue
+  sleep(secs)
+end
+
+def section(name)
+  timestamp = Time.now.utc.iso8601
+  puts ''
+  puts "[#{timestamp}] >>>>>>>>>>>>>> #{name} STAGE".black.on_white
+  puts ''
+end
+
+def in_venv
+  ENV['RUN_VENV'] && ENV['RUN_VENV'] == 'true' ? true : false
+end
+
+def install_requirements(req_file, pip_options = nil, output = nil, use_venv = nil)
+  pip_command = use_venv ? "#{ENV['SDK_HOME']}/venv/bin/pip" : 'pip'
+  redirect_output = output ? "2>&1 >> #{output}" : ''
+  pip_options = '' if pip_options.nil?
+  File.exist?(req_file) && File.open(req_file, 'r') do |f|
+    f.each_line do |line|
+      line.strip!
+      unless line.empty? || line.start_with?('#')
+        sh %(#{pip_command} install #{line} #{pip_options} #{redirect_output}\
+             || echo 'Unable to install #{line}' #{redirect_output})
+      end
+    end
+  end
+end
+
+def test_files(sdk_dir)
+  Dir.glob(File.join(sdk_dir, '**/test_*.py')).reject do |path|
+    !%r{#{sdk_dir}/embedded/.*$}.match(path).nil? || !%r{#{sdk_dir}\/venv\/.*$}.match(path).nil?
+  end
+end
+
+def integration_tests(ci_dir)
+  sdk_dir = File.join(ci_dir, '..')
+  integrations = []
+  untested = []
+  testable = []
+  test_files(sdk_dir).each do |check|
+    integration_name = /test_((\w|_)+).py$/.match(check)[1]
+    integrations.push(integration_name)
+    if Dir.exist?(File.join(sdk_dir, integration_name))
+      testable.push(check)
+    else
+      untested.push(check)
+    end
+  end
+  [testable, untested]
+end
+
+# helper class to wait for TCP/HTTP services to boot
+class Wait
+  DEFAULT_TIMEOUT = 10
+
+  def self.check_port(port)
+    Timeout.timeout(0.5) do
+      begin
+        s = TCPSocket.new('localhost', port)
+        s.close
+        return true
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+        return false
+      end
+    end
+  rescue Timeout::Error
+    return false
+  end
+
+  def self.check_url(url)
+    Timeout.timeout(0.5) do
+      begin
+        r = HTTParty.get(url)
+        return (200...300).cover? r.code
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+        return false
+      end
+    end
+  rescue Timeout::Error
+    return false
+  end
+
+  def self.check_file(file_path)
+    File.exist?(file_path)
+  end
+
+  def self.check(smth)
+    if smth.is_a? Integer
+      check_port smth
+    elsif smth.include? 'http'
+      check_url smth
+    else
+      check_file smth
+    end
+  end
+
+  def self.for(smth, max_timeout = DEFAULT_TIMEOUT)
+    start_time = Time.now
+    status = false
+    n = 1
+    puts "Trying #{smth}"
+    loop do
+      puts n.to_s
+      status = check(smth)
+      break if status || Time.now > start_time + max_timeout
+      n += 1
+      sleep 0.25
+    end
+    raise "Still not up after #{max_timeout}s" unless status
+    puts 'Found!'
+    status
+  end
+end
+
+namespace :ci do
+  namespace :common do
+    task :before_install do |t|
+      section('BEFORE_INSTALL')
+      # We use tempdir on Windows, no need to create it
+      sh %(mkdir -p #{ENV['VOLATILE_DIR']}) unless Gem.win_platform?
+      t.reenable
+    end
+
+    task :install do |t|
+      section('INSTALL')
+      use_venv = in_venv
+      pip_command = use_venv ? 'venv/bin/pip' : 'pip'
+      sh %(#{'python -m ' if Gem.win_platform?}#{pip_command} install --upgrade pip setuptools)
+      install_requirements('requirements.txt',
+                           "--cache-dir #{ENV['PIP_CACHE']}",
+                           "#{ENV['VOLATILE_DIR']}/ci.log", use_venv)
+      install_requirements('requirements-opt.txt',
+                           "--upgrade --cache-dir #{ENV['PIP_CACHE']}",
+                           "#{ENV['VOLATILE_DIR']}/ci.log", use_venv)
+      install_requirements('requirements-test.txt',
+                           "--cache-dir #{ENV['PIP_CACHE']}",
+                           "#{ENV['VOLATILE_DIR']}/ci.log", use_venv)
+      t.reenable
+    end
+
+    task :before_script do |t|
+      section('BEFORE_SCRIPT')
+      t.reenable
+    end
+
+    task :script do |t|
+      section('SCRIPT')
+      t.reenable
+    end
+
+    task :before_cache do |t|
+      section('BEFORE_CACHE')
+      t.reenable
+    end
+
+    task :cleanup do |t|
+      section('CLEANUP')
+      t.reenable
+    end
+
+    task :run_tests, [:flavor, :cihome, :mocked] do |t, attr|
+      flavors = attr[:flavor]
+      cihome = attr[:cihome]
+      mocked = attr[:mocked] || false
+      filter = ENV['NOSE_FILTER'] || '1'
+      nose_command = in_venv ? 'venv/bin/nosetests' : 'nosetests'
+
+      mock_filter = mocked ? "mock" : "not mock"
+      nose = if flavors.include?('default')
+               "(not requires) and #{filter} and #{mock_filter}"
+             else
+               "(requires in ['#{flavors.join("','")}']) and #{filter} and #{mock_filter}"
+             end
+
+      tests_directory, = integration_tests(cihome)
+      unless flavors.include?('default')
+        tests_directory = tests_directory.reject do |test|
+          /.*#{flavors}.*$/.match(test).nil?
+        end
+      end
+      # Rake on Windows doesn't support setting the var at the beginning of the
+      # command
+      path = ''
+      unless Gem.win_platform?
+        # FIXME: make the other filters than param configurable
+        # For integrations that cannot be easily installed in a
+        # separate dir we symlink stuff in the rootdir
+        path = %(PATH="#{ENV['INTEGRATIONS_DIR']}/bin:#{ENV['PATH']}" )
+      end
+      tests_directory.each do |testdir|
+        sh %(#{path}#{nose_command} -s -v -A "#{nose}" #{testdir})
+      end
+      t.reenable
+    end
+
+    task execute: [:before_install, :install, :before_script, :script]
+  end
+end

data/lib/tasks/ci/default.rb

@@ -0,0 +1,67 @@
+require 'rake'
+
+require 'ci/common'
+require 'bundler'
+
+namespace :ci do
+  namespace :default do |flavor|
+    task before_install: ['ci:common:before_install']
+
+    task :coverage do
+      check_env
+      testable, untested = integration_tests(File.dirname(__FILE__))
+      total_checks = (untested + testable).length
+      unless untested.empty?
+        puts "Untested checks (#{untested.length}/#{total_checks})".red
+        puts '-----------------------'.red
+        untested.each { |check_name| puts check_name.red }
+        puts ''
+      end
+    end
+
+    task install: ['ci:common:install']
+
+    task before_script: ['ci:common:before_script']
+
+    task lint: ['rubocop'] do
+      check_env
+      sh %(flake8 #{ENV['SDK_HOME']})
+      sh %(find #{ENV['SDK_HOME']} -name '*.py' -not\
+             \\( -path '*.cache*' -or -path '*embedded*' -or -path '*venv*' -or -path '*.git*' \\)\
+             | xargs -n 1 pylint --rcfile=#{ENV['SDK_HOME']}/.pylintrc)
+    end
+
+    task :requirements do
+      check_env
+      gem_home = Bundler.rubygems.find_name('datadog-sdk-testing').first.full_gem_path
+      sh "#{gem_home}/lib/tasks/ci/hooks/pre-commit.py"
+    end
+
+    task script: ['ci:common:script', :coverage, :lint] do
+      check_env
+      Rake::Task['ci:common:run_tests'].invoke(['default'])
+    end
+
+    task cleanup: ['ci:common:cleanup']
+
+    task :execute do
+      exception = nil
+      begin
+        %w(before_install install before_script
+           script).each do |t|
+          Rake::Task["#{flavor.scope.path}:#{t}"].invoke
+        end
+      rescue => e
+        exception = e
+        puts "Failed task: #{e.class} #{e.message}".red
+      end
+      if ENV['SKIP_CLEANUP']
+        puts 'Skipping cleanup, disposable environments are great'.yellow
+      else
+        puts 'Cleaning up'
+        Rake::Task["#{flavor.scope.path}:cleanup"].invoke
+      end
+      raise exception if exception
+    end
+  end
+end

data/lib/tasks/ci/hooks/pre-commit.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+
+import fnmatch
+import os
+import sys
+
+OK = 0
+ERR = 1
+
+def get_files(fname):
+    matches = []
+    for root, dirnames, filenames in os.walk('.'):
+        for filename in fnmatch.filter(filenames, fname):
+            matches.append(os.path.join(root, filename))
+
+    return matches
+
+
+def process_requirements(reqs, fname):
+    SPECIFIERS = ['==', '!=' '<=', '>=', '<', '>']
+
+    print "processing... {}".format(fname)
+    with open(fname) as f:
+        content = f.readlines()
+
+    for line in content:
+        line = "".join(line.split())
+        for specifier in SPECIFIERS:
+            idx = line.find(specifier)
+            if idx < 0:
+                continue
+
+            req = line[:idx]
+            specifier = line[idx:]
+
+            if req in reqs and reqs[req][0] != specifier:
+                # version mismatch
+                print "There's a version mismatch with {req} " \
+                    " {spec} and {prev_spec} defined in {src}.".format(
+                        req=req,
+                        spec=specifier,
+                        prev_spec=reqs[req][0],
+                        src=reqs[req][1]
+                    )
+                sys.exit(ERR)
+            elif req not in reqs:
+                reqs[req] = (specifier, fname)
+                break
+
+
+requirements = {}
+files = get_files('requirements.txt')
+
+for f in files:
+    process_requirements(requirements, f)
+
+print "No requirement version conflicts found. Looking good... ;)"
+for req, spec in requirements.iteritems():
+    print "{req}{spec} first found in {fname}".format(
+        req=req,
+        spec=spec[0],
+        fname=spec[1]
+    )
+
+sys.exit(OK)

data/lib/tasks/sdk.rake

@@ -0,0 +1,152 @@
+#!/usr/bin/env rake
+# encoding: utf-8
+# 3p
+require 'rake/clean'
+require 'rubocop/rake_task'
+require 'bundler'
+
+# Flavored Travis CI jobs
+require 'ci/default'
+Rake.add_rakelib './ci/'
+
+CLOBBER.include '**/*.pyc'
+
+desc 'Setup a development environment for the SDK'
+task 'setup_env' do
+  check_env
+  `mkdir -p #{ENV['SDK_HOME']}/venv`
+  `wget -q -O #{ENV['SDK_HOME']}/venv/virtualenv.py https://raw.github.com/pypa/virtualenv/1.11.6/virtualenv.py`
+  `python #{ENV['SDK_HOME']}/venv/virtualenv.py  --no-site-packages --no-pip --no-setuptools #{ENV['SDK_HOME']}/venv/`
+  `wget -q -O #{ENV['SDK_HOME']}/venv/ez_setup.py https://bootstrap.pypa.io/ez_setup.py`
+  `#{ENV['SDK_HOME']}/venv/bin/python #{ENV['SDK_HOME']}/venv/ez_setup.py`
+  `wget -q -O #{ENV['SDK_HOME']}/venv/get-pip.py https://bootstrap.pypa.io/get-pip.py`
+  `#{ENV['SDK_HOME']}/venv/bin/python #{ENV['SDK_HOME']}/venv/get-pip.py`
+  # these files should be part of the SDK repos (integrations-{core, extra}
+  `venv/bin/pip install -r #{ENV['SDK_HOME']}/requirements.txt` if File.exist?('requirements.txt')
+  `venv/bin/pip install -r #{ENV['SDK_HOME']}/requirements-test.txt` if File.exist?('requirements-test.txt')
+  # These deps are not really needed, so we ignore failures
+  ENV['PIP_COMMAND'] = "#{ENV['SDK_HOME']}/venv/bin/pip"
+  `git clone https://github.com/DataDog/dd-agent.git #{ENV['SDK_HOME']}/embedded/dd-agent`
+  # install agent core dependencies
+  `#{ENV['SDK_HOME']}/venv/bin/pip install -r #{ENV['SDK_HOME']}/embedded/dd-agent/requirements.txt`
+  `echo "#{ENV['SDK_HOME']}/embedded/dd-agent/" > #{ENV['SDK_HOME']}/venv/lib/python2.7/site-packages/datadog-agent.pth`
+end
+
+desc 'Clean development environment for the SDK (remove!)'
+task 'clean_env' do
+  check_env
+  input = ''
+  print "Are you sure you want to delete the SDK environment (y/n)? "
+  input = STDIN.gets.chomp
+  case input.upcase
+  when "Y"
+    `rm -rf #{ENV['SDK_HOME']}/venv` if File.directory?("#{ENV['SDK_HOME']}/venv")
+    `rm -rf #{ENV['SDK_HOME']}/embedded` if File.directory?("#{ENV['SDK_HOME']}/embedded")
+    puts "virtual environment, agent source removed."
+  when "N"
+    puts "aborting the task..."
+  end
+end
+
+desc 'Setup git hooks'
+task 'setup_hooks' do
+  check_env
+  gem_home = Bundler.rubygems.find_name('datadog-sdk-testing').first.full_gem_path
+  sh "ln -sf #{gem_home}/lib/tasks/ci/hooks/pre-commit.py #{ENV['SDK_HOME']}}/.git/hooks/pre-commit"
+end
+
+desc 'Pull latest agent code'
+task 'pull_latest_agent' do
+  check_env
+  `cd #{ENV['SDK_HOME']}/embedded/dd-agent && git fetch -p && git pull && cd -`
+end
+
+namespace :test do
+  desc 'cProfile tests, then run pstats'
+  task 'profile:pstats' => ['test:profile'] do
+    check_env
+    sh 'python -m pstats stats.dat'
+  end
+
+  desc 'Display test coverage for checks'
+  task 'coverage' => 'ci:default:coverage'
+end
+
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.patterns = ['ci/**/*.rb', 'Gemfile', 'Rakefile']
+end
+
+desc 'Lint the code through pylint'
+task 'lint' => ['ci:default:lint'] do
+end
+
+desc 'Find requirements conflicts'
+task 'requirements' => ['ci:default:requirements'] do
+end
+
+namespace :generate do
+  desc 'Setup a development environment for the SDK'
+  task :skeleton, :option do |_, args|
+    check_env
+    puts "generating skeleton files for #{args[:option]}"
+    gem_home = Bundler.rubygems.find_name('datadog-sdk-testing').first.full_gem_path
+    capitalized = args[:option].capitalize
+    sh "mkdir -p #{ENV['SDK_HOME']}/ci"
+    sh "mkdir -p #{ENV['SDK_HOME']}/#{args[:option]}"
+    sh "cp #{gem_home}/lib/config/ci/skeleton.rake #{ENV['SDK_HOME']}/ci/#{args[:option]}.rake"
+    sh "cp #{gem_home}/lib/config/manifest.json #{ENV['SDK_HOME']}/#{args[:option]}/manifest.json"
+    sh "cp #{gem_home}/lib/config/check.py #{ENV['SDK_HOME']}/#{args[:option]}/check.py"
+    sh "cp #{gem_home}/lib/config/test_skeleton.py #{ENV['SDK_HOME']}/#{args[:option]}/test_#{args[:option]}.py"
+    sh "cp #{gem_home}/lib/config/metadata.csv #{ENV['SDK_HOME']}/#{args[:option]}/metadata.csv"
+    sh "cp #{gem_home}/lib/config/requirements.txt #{ENV['SDK_HOME']}/#{args[:option]}/requirements.txt"
+    sh "cp #{gem_home}/lib/config/README.md #{ENV['SDK_HOME']}/#{args[:option]}/README.md"
+    sh "find #{ENV['SDK_HOME']}/#{args[:option]} -type f -exec sed -i '' \"s/skeleton/#{args[:option]}/g\" {} \\;"
+    sh "find #{ENV['SDK_HOME']}/#{args[:option]} -type f -exec sed -i '' \"s/Skeleton/#{capitalized}/g\" {} \\;"
+    sh "sed -i '' \"s/skeleton/#{args[:option]}/g\" #{ENV['SDK_HOME']}/ci/#{args[:option]}.rake"
+    sh "sed -i '' \"s/Skeleton/#{capitalized}/g\" #{ENV['SDK_HOME']}/ci/#{args[:option]}.rake"
+    sh "git add #{ENV['SDK_HOME']}/ci/#{args[:option]}.rake"
+    sh "git add #{ENV['SDK_HOME']}/#{args[:option]}/*"
+
+    new_file = "#{ENV['SDK_HOME']}/circle.yml.new"
+    File.open(new_file, 'w') do |fo|
+      File.foreach("#{ENV['SDK_HOME']}/circle.yml") do |line|
+        fo.puts "        - rake ci:run[#{args[:option]}]" if line =~ /bundle\ exec\ rake\ requirements/
+        fo.puts line
+      end
+    end
+    File.delete("#{ENV['SDK_HOME']}/circle.yml")
+    File.rename(new_file, "#{ENV['SDK_HOME']}/circle.yml")
+
+    new_file = "#{ENV['SDK_HOME']}/.travis.yml.new"
+    File.open(new_file, 'w') do |fo|
+      File.foreach("#{ENV['SDK_HOME']}/.travis.yml") do |line|
+        fo.puts "  - rake ci:run[#{args[:option]}]" if line =~ /bundle\ exec\ rake\ requirements/
+        fo.puts line
+      end
+    end
+    File.delete("#{ENV['SDK_HOME']}/.travis.yml")
+    File.rename(new_file, "#{ENV['SDK_HOME']}/.travis.yml")
+  end
+end
+
+namespace :ci do
+  desc 'Run integration tests'
+  task :run, [:flavor, :mocked] do |_, args|
+    check_env
+    puts 'Assuming you are running these tests locally' unless ENV['TRAVIS']
+    flavor = args[:flavor] || ENV['TRAVIS_FLAVOR'] || 'default'
+    mocked = args[:mocked] || false
+    flavors = flavor.split(',')
+    flavors.each do |f|
+      Rake::Task["ci:#{f}:execute"].invoke(mocked)
+    end
+  end
+
+  desc 'Run mock tests'
+  task :run_mocks, [:flavor] do |_, args|
+    check_env
+    Rake::Task["ci:run"].invoke(args[:flavor], true)
+  end
+end
+
+task default: ['lint', 'ci:run']

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: datadog-sdk-testing
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jaime Fullaondo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-16 00:00:00.000000000 Z
+dependencies: []
+description: Datadog Integration SDK testing/scaffolding gem
+email: jaime.fullaondo@datadoghq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/config/README.md
+- lib/config/check.py
+- lib/config/ci/skeleton.rake
+- lib/config/conf.yaml.example
+- lib/config/manifest.json
+- lib/config/metadata.csv
+- lib/config/requirements.txt
+- lib/config/test_skeleton.py
+- lib/tasks/ci/common.rb
+- lib/tasks/ci/default.rb
+- lib/tasks/ci/hooks/pre-commit.py
+- lib/tasks/sdk.rake
+homepage: http://rubygems.org/gems/datadog-sdk-testing
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib/tasks/
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Datadog Integration SDK testing/scaffolding facilities.
+test_files: []