cutting_edge 0.0.1 → 0.1

data/lib/cutting_edge/workers/helpers.rb

@@ -14,6 +14,14 @@ module WorkerHelpers
   def get_from_store(identifier)
     ::CuttingEdge::App.store[identifier]
   end
+  
+  def badge_worker(identifier)
+    BadgeWorker.perform_async(identifier)
+  end
+  
+  def mail_worker(identifier, to_address)
+    MailWorker.perform_async(identifier, to_address)
+  end
 
 end
 

data/lib/cutting_edge/workers/mail.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../helpers.rb', __FILE__)
+require 'erb'
+require 'mail'
+
+module CuttingEdge
+  MAIL_TEMPLATE = File.read(File.expand_path('../../templates/mail.html.erb', __FILE__)) unless defined?(MAIL_TEMPLATE)
+end
+
+class MailWorker < GenericWorker
+  
+  def perform(identifier, to_addr)
+    log_info('Running Worker!')
+    dependencies = get_from_store(identifier)
+    unless to_addr && dependencies
+      log_info("Failed to execute email job for #{identifier}: #{dependencies ? dependencies : 'No dependencies found.'} #{'No e-mail address set.' if to_addr.nil?}")
+      return nil
+    end
+
+    Mail.deliver do
+      from     "CuttingEdge <#{CuttingEdge::MAIL_FROM}>"
+      to       to_addr
+      subject  "Dependency Status Changed For #{identifier}"
+      
+      text_part do
+        body "Dependency Status Update For #{identifier} By CuttingEdge"
+      end
+      
+      html_part do
+        content_type 'text/html; charset=UTF-8'
+        body  ERB.new(CuttingEdge::MAIL_TEMPLATE).result_with_hash(
+          project: identifier,
+          url: CuttingEdge::SERVER_URL,
+          specs: dependencies
+        )
+      end
+    end
+  end
+end

data/projects.yml

@@ -0,0 +1,25 @@
+# Example projects.yml file for CuttingEdge
+# For more information and options, see: https://github.com/repotag/cutting_edge
+
+github:
+  repotag:
+    cutting_edge:
+      language: ruby
+      hide: mysecret
+  gollum:
+    gollum:
+      language: ruby
+    gollum-lib:
+      locations: [gemspec.rb]
+      dependency_types: [runtime, development]
+  singingwolfboy:
+    flask-dance:
+      language: python
+      email: false
+  rust-lang:
+    crates.io:
+      language: rust
+gitlab:
+  cthowl01:
+    team-chess-ruby:
+      locations: [Gemfile]

data/spec/app_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe CuttingEdgeHelpers do
+  it 'fails to load invalid projects.yml' do
+    expect(load_repositories('/tmp/fail.yml')).to be_nil
+  end
+end
+
+describe CuttingEdge::App do
+  before(:all) {
+    CuttingEdge::App.set(:repositories, load_repositories(File.expand_path('../fixtures/projects.yml', __FILE__)))
+    CuttingEdge::App.set(:store, Moneta.new(:Memory))
+  }
+  let(:app) { CuttingEdge::App.new }
+
+  context 'landing page' do
+    let(:response) { get '/' }
+    it 'returns status 200 OK' do
+      expect(response.status).to eq 200
+    end
+  end
+  
+  context 'unknown project' do
+    let(:project) { 'github/doesnt/exist' }
+    ['/info', '/info/json', '/svg', '/refresh'].each do |route|
+      it "returns status 404 not found for #{route}" do
+        response = get("/#{project}#{route}")
+        expect(response.status).to eq 404
+      end
+    end
+  end
+  
+  context 'known project' do
+    let(:project) { 'github/gollum/gollum' }
+    before {
+      add_to_store("svg-#{project}", 'test')
+      add_to_store(project, {'test' => true})
+    }
+    {'/info' => 'text/html;charset=utf-8', '/info/json' => 'application/json', '/svg' => 'image/svg+xml'}.each do |route, type|
+      it "returns status 200 OK for #{route} with mime #{type}" do
+        response = get("/#{project}#{route}")
+        expect(response.status).to eq 200
+        expect(response.content_type).to eq type
+      end
+    end
+    
+    it 'returns status 500 for a known project json without data' do
+      response = get("/github/gollum/gollum-lib/info/json")
+      # the store contains nothing for gollum-lib
+      expect(response.status).to eq 500
+    end
+    
+    it 'svgs have cache-control: no-cache' do
+      response = get("/#{project}/svg")
+      expect(response.headers['Cache-Control']).to eq 'no-cache'
+    end
+  end
+  
+  context 'hidden repos' do
+    let(:project) { 'gitlab/gitlab-org/gitlab-foss' }
+    let(:repo) { CuttingEdge::App.repositories[project] }
+    
+    it 'does not list hidden repos on the landing page' do
+      response = get('/')
+      expect(response.body).to include('team-chess-ruby')
+      expect(response.body).not_to include('gitlab-foss')
+    end
+    
+    before {
+      ::CuttingEdge::SECRET_TOKEN = 'secret'
+      add_to_store(project, {'test' => true})
+    }
+    after {
+      CuttingEdge.send(:remove_const, :SECRET_TOKEN)
+    }
+    
+    it 'returns a JSON encoded HTML partial if the token is correct' do
+      response = post('/hidden_repos', "{\"token\":\"secret\"}")
+      expect(response.body).to include('gitlab-foss')
+      expect(JSON.parse(response.body)['partial']).to include "<div class=\"Box\">"
+      expect(JSON.parse(response.body)['partial']).to include "gitlab/gitlab-org/gitlab-foss"
+    end
+    
+    it 'only gives access to repo information with the repo hidden token' do
+      ['/info', '/info/json', '/svg'].each do |route|
+        url = File.join('/', project, route)
+        unauthorized_response = get(url)
+        expect(unauthorized_response.status).to eq 404
+        authorized_response = get(url, token: repo.hidden_token)
+        expect(authorized_response.status).to eq 200
+      end
+    end
+    
+  end
+  
+  context 'refreshing' do
+    let(:project) { 'github/gollum/gollum' }
+    before {
+      ::CuttingEdge::SECRET_TOKEN = 'secret'
+    }
+    after {
+      CuttingEdge.send(:remove_const, :SECRET_TOKEN)
+    }
+    
+    it 'fails with wrong token' do
+      response = post "/#{project}/refresh", :token => 'fail'
+      expect(response.status).to eq 401
+    end
+    it 'succeeds with right token' do
+      expect(DependencyWorker).to receive(:perform_async).exactly(:once)
+      response = post "/#{project}/refresh", token: 'secret'
+      expect(response.status).to eq 200
+    end
+  end
+end

data/spec/badge_worker_spec.rb

@@ -0,0 +1,77 @@
+standard_svg = <<EOF
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="100" height="20" role="img" aria-label="CuttingEdge Dependency Status">
+    <title>CuttingEdge Dependency Status</title>
+    <linearGradient id="s" x2="0" y2="100%">
+        <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+        <stop offset="1" stop-opacity=".1"/>
+    </linearGradient>
+    <clipPath id="r">
+        <rect width="100" height="20" rx="3" fill="#fff"/>
+    </clipPath>
+    <g clip-path="url(#r)">
+        <rect width="35" height="20" fill="#555"/>
+        
+        <rect x="25" width="25" height="20" fill="#4c1"/>
+        
+        <rect x="50" width="25" height="20" fill="#fe7d37"/>
+        
+        <rect x="75" width="25" height="20" fill="#e05d44"/>
+        
+        <rect width="100" height="20" fill="url(#s)"/>
+    </g>
+    <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110">
+        
+        <text aria-hidden="true" x="125" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)">CE</text>
+        <text x="125" y="140" transform="scale(.1)" fill="#fff">CE</text>
+        
+        
+        <g>
+          <title>Ok: 3</title>
+          <text aria-hidden="true" x="370" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)">3</text>
+          <text x="370" y="140" transform="scale(.1)" fill="#fff">3</text>        
+        </g>
+        
+        <g>
+          <title>Outdated Minor: 1</title>
+          <text aria-hidden="true" x="620" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)">1</text>
+          <text x="620" y="140" transform="scale(.1)" fill="#fff">1</text>        
+        </g>
+        
+        <g>
+          <title>Outdated Major: 3</title>
+          <text aria-hidden="true" x="870" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)">3</text>
+          <text x="870" y="140" transform="scale(.1)" fill="#fff">3</text>        
+        </g>
+        
+    </g>
+</svg>
+EOF
+describe BadgeWorker do
+  let(:worker) { BadgeWorker.new }
+  let(:identifier) { 'github/gollum/gollum' }
+
+  let(:dependencies) {
+    mock_dependencies('gollum')
+  }
+  
+  context 'performing' do
+  
+    it 'generates an svg for outdated dependencies' do
+      expect(worker).to receive(:get_from_store).with(identifier).and_return(dependencies)
+      expect(worker).to receive(:add_to_store).with("svg-#{identifier}", standard_svg.chomp).and_return(true)
+      worker.perform(identifier)
+    end
+    
+    it 'shows an error badge when there are no dependencies' do
+      expect(worker).to receive(:get_from_store).with(identifier).and_return(nil)
+      expect(worker).to receive(:add_to_store).with("svg-#{identifier}", CuttingEdge::BADGE_ERROR).and_return(true)
+      worker.perform(identifier)
+    end
+    
+    it 'shows an ok badge when up to date' do
+      expect(worker).to receive(:get_from_store).with(identifier).and_return(mock_dependencies('ok'))
+      expect(worker).to receive(:add_to_store).with("svg-#{identifier}", CuttingEdge::BADGE_OK).and_return(true)
+      worker.perform(identifier)
+    end
+  end
+end

data/spec/dependency_worker_spec.rb

@@ -0,0 +1,132 @@
+class MockResponse
+  def initialize(status, body)
+    @status = status
+    @body = body
+  end
+  
+  attr_reader :status
+  
+  def to_s
+    @body
+  end
+end
+
+describe DependencyWorker do
+  let(:worker) { DependencyWorker.new }
+  let(:identifier) { 'github/gollum/gollum' }
+  let(:test_email) { 'cutting_edge@localhost' }
+  let(:lang) { 'ruby' }
+  let(:locations) {
+    {
+      'gollum.gemspec' => 'http://github.bla/gollum/gollum/gollum.gemspec',
+      'Gemfile' => 'http://github.bla/gollum/gollum/Gemfile'
+    }
+  }
+  let(:dependency_types) { [:runtime] }
+  let(:old_dependencies) {
+    mock_dependencies('gollum')
+  }
+  let(:new_dependencies) {
+    mock_dependencies('gollum-updated')
+  }
+  
+  context 'http fetching files' do
+    let(:response_ok) { MockResponse.new(200, 'body') }
+    let(:response_not_found) { MockResponse.new(404, 'Not found') }
+    let(:url) { locations.first.last }
+    before {
+      worker.instance_variable_set(:@provider, ::CuttingEdge::GitlabRepository)
+    }
+    
+    it 'uses default headers' do
+      worker.instance_variable_set(:@provider, ::CuttingEdge::GithubRepository)
+      expect(HTTP).to receive(:headers).with({:accept => 'application/vnd.github.v3.raw'}).exactly(:once).and_call_original
+      expect_any_instance_of(HTTP::Client).to receive(:get).with(url).and_return(response_ok)
+      expect(worker.send(:http_get, url)).to eq 'body'
+    end
+
+    it 'returns body when http get is successful' do
+      expect_any_instance_of(HTTP::Client).to receive(:get).with(url).and_return(response_ok)
+      expect(worker.send(:http_get, url)).to eq 'body'
+    end
+    
+    it 'uses an auth header when it is set for project' do
+      token = 'token'
+      header = "Bearer #{token}"
+      worker.instance_variable_set(:@auth_token, token)
+      expect(::CuttingEdge::GitlabRepository).to receive(:headers).with(token).exactly(:once).and_call_original
+      expect(HTTP).to receive(:headers).with(:authorization => 'Bearer token').exactly(:once).and_call_original
+      expect_any_instance_of(HTTP::Client).to receive(:get).with(url).and_return(response_ok)
+      expect(worker.send(:http_get, url)).to eq 'body'
+    end
+    
+    it 'returns body when http get is unsuccessful' do
+      expect_any_instance_of(HTTP::Client).to receive(:get).with(url).and_return(response_not_found)
+      expect(worker.send(:http_get, url)).to be_nil
+    end
+        
+    it 'handles a timeout' do
+      expect_any_instance_of(HTTP::Client).to receive(:get).with(url).and_raise(HTTP::TimeoutError)
+      expect(worker).to receive(:log_info)
+      expect(worker.send(:http_get, url)).to be_nil
+    end
+  end
+  
+  it 'generates results for fetched requirements' do
+    worker.instance_variable_set(:@lang, RubyLang)
+    fetched = [RubyLang.unknown_dependency('unknown_requirement'), Gem::Version.new('1.0')]
+    result_no_requirement = {:no_requirement=>[{:latest=>"1.0", :name=>"unknown_requirement", :required=>"unknown", :type=>:runtime, :url=>nil}], :ok=>[], :outdated_major=>[], :outdated_minor=>[], :outdated_patch=>[], :unknown=>[]}
+    expect(worker.send(:get_results, [fetched], dependency_types)).to eq result_no_requirement
+    
+    fetched = [Gem::Dependency.new('unknown_version', '1.0', :runtime), nil]
+    result_no_version = {:no_requirement=>[], :ok=>[], :outdated_major=>[], :outdated_minor=>[], :outdated_patch=>[], :unknown=>[{:latest=>"", :name=>"unknown_version", :required=>"= 1.0", :type=>:runtime, :url=>"https://rubygems.org/gems/unknown_version"}]}
+    expect(worker.send(:get_results, [fetched], dependency_types)).to eq result_no_version
+  end 
+  
+  context 'performing' do
+  
+    before(:each) {
+      expect(worker).to receive(:get_from_store).with(identifier).and_return(old_dependencies)
+      expect(worker).to receive(:http_get).and_return('fake').exactly(locations.length).times
+    }
+    
+    context 'when the dependencies have changed' do
+    
+      before(:each) {
+        locations.each_key do |loc|
+          expect(RubyLang).to receive(:parse_file).with(loc, 'fake').and_return(mock_fetched_requirements('gollum', loc, true))
+        end
+        expect(worker).to receive(:badge_worker).with(identifier).and_return(true)
+        expect(worker).to receive(:mail_worker).with(identifier, test_email).and_return(true)
+      }
+    
+      it 'updates the store with newest dependencies' do
+        expect(worker).to receive(:add_to_store).with(identifier, new_dependencies).and_return(true)
+        expect(worker.instance_variable_get(:@nothing_changed)).to be_nil
+        worker.perform(identifier, lang, locations, dependency_types, test_email)
+        expect(worker.instance_variable_get(:@nothing_changed)).to be false
+      end
+    
+    end
+
+    context 'when the dependencies have not changed' do
+    
+      before(:each) {
+        locations.each_key do |loc|
+          expect(RubyLang).to receive(:parse_file).with(loc, 'fake').and_return(mock_fetched_requirements('gollum', loc, false))
+        end
+        expect(worker).not_to receive(:badge_worker)
+        expect(worker).not_to receive(:mail_worker)
+      }
+      
+      it 'does not update the store' do
+        expect(worker).not_to receive(:add_to_store)
+        expect(worker.instance_variable_get(:@nothing_changed)).to be_nil
+        worker.perform(identifier, lang, locations, dependency_types, test_email)
+        expect(worker.instance_variable_get(:@nothing_changed)).to be true
+      end
+    
+    end
+  
+  end
+end

data/spec/email_worker_spec.rb

@@ -0,0 +1,43 @@
+require 'mail'
+Mail.defaults do
+  delivery_method :test
+end
+
+describe MailWorker do
+  let(:worker) { MailWorker.new }
+  let(:identifier) { 'github/repotag/cutting_edge' }
+  let(:test_email) { 'cutting_edge@localhost' }
+  let(:dependencies) {
+    mock_dependencies('gollum')
+  }
+  
+  before(:each) {
+    expect(worker).to receive(:get_from_store).with(identifier).and_return(dependencies)
+  }
+  
+  it 'returns nil when to address is nil ' do  
+    expect(worker.perform(identifier, nil)).to eq nil
+  end
+  
+  it 'sends an update mail' do
+    expect(Mail::TestMailer.deliveries).to be_empty
+    worker.perform(identifier, test_email)
+    expect(Mail::TestMailer.deliveries).to_not be_empty
+    
+    mail = Mail::TestMailer.deliveries.first
+    expect(mail.from.first).to eq 'cutting_edge@localhost'
+    expect(mail.to.first).to eq test_email
+    expect(mail.subject).to eq  "Dependency Status Changed For #{identifier}"
+    
+    body = mail.body
+    expect(body.parts.length).to eq 2
+    
+    html_body = body.parts.last.to_s
+    expect(html_body).to start_with('Content-Type: text/html')
+    expect(html_body).to include('This is <a href="http://localhost">CuttingEdge</a> informing you')
+    expect(html_body).to include("<a href=\"http://localhost/#{identifier}/info\">#{identifier}</a>")
+    expect(html_body).to include('In <b>gollum.gemspec</b>:')
+    expect(html_body).to include('<b>Outdated Major</b>:')
+    expect(html_body).to include('<li>rake ~> 12.3, >= 12.3.3 (latest: 13.0.1)</li>')
+  end
+end