testing_your_legacy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cca438f1b58bc6facde234da7667c460a5417abd
+  data.tar.gz: b75b0f785770a5c168928c1587273c3b17c7e0af
+SHA512:
+  metadata.gz: 1f97630931260738a514822892a456f91f49f987a37f0975d86578e84c780d7fc8be3afb9fd48d4b4b1eb59f0b671e781fe96982b2496a0a0fed7ebbe7160e2e
+  data.tar.gz: e61b9b77be2429bea963ed9191b830a435fbf0da29a26883b064801cf19ee44b68196165b1fbe6bc825615203cafd6cc15474368d48ef75c3a90291835722fd9

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in your_legacy_tests.gemspec
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    testing_your_legacy (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.8.3)
+    rake (10.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  minitest
+  rake (~> 10.0)
+  testing_your_legacy!
+
+BUNDLED WITH
+   1.10.6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Timothy Nordloh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,218 @@
+# YourLegacyTests
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'your_legacy_tests'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install your_legacy_tests
+
+## Usage
+
+
+This gem should be used by people who have inherited a legacy application which lacks any tests, but has been running in production for a while.  It uses Sumo Logic to find the most frequently used urls in an application, and then generates tests for those urls.
+
+To run, execute the command:
+
+`tests_via_sumo [-c or --count <count>] [-s or --source_category <category>]`
+
+source_category defaults to a * .
+
+Count defaults to 25, and controls the number of tests generated.
+
+Results are generated on stdout, for maximum flexibility on where the tests are placed in the Rails application.
+
+
+## Caveats
+
+Since Sumo Logic is nice enough to process logs for free, for smaller users, I'm releasing this gem with heavy dependence on Sumo's query function, for now.  I plan on adding hooks to allow it to be more useful for processing logfiles without relying on Sumo for summing up the number of visits per page, ordering them from greatest to smallest, and parsing data out of the logfiles.
+
+### Prerequisites
+
+Currently, this gem requires an active account with sumologic, and that you read your logfiles into sumologic.  It then uses their api to aggregate the results, and create tests, based on frequency.
+
+After reading log files with Sumo, run the sumo_sum command.  It will prompt you to fill in the ~/.sumo_creds file, with your credentials, if you haven't already.  Otherwise, it should parse your sumo  logs, and return a list of tests to your command line, which you can pipe into a test file of your choise.
+
+All of the tests are initially set to `skip`, so that you can enable them one at a time. Start at the first test, which is the most-visited link, and try to run it.  It may need to have some prerequisites filled in; for example, perhaps it requires that the user be logged in, which may require you to create a relevant fixture, and ensure that a login url is called first.
+
+
+#### Examples
+
+These examples assume no real knowledge on building tests, other than the ability to run the `rake test` command; it is a summary of the things I wish I knew, when I tried to figure out how to test my legacy application, so if you are already familiar with writing tests, you may want to just skim this section.
+
+
+
+#### Example 1:  Base url test
+
+I took the output from `tests_via_sumo`, and appended them to the `./test/integration/user_stories_test.rb` file.
+
+Modifying the auto-generated test to work for you:
+
+```ruby
+test "visit /" do
+  skip
+  #this url was visited 1647 times
+  get '/'
+  assert_response :success
+end
+```
+
+After uncommenting the `skip`, and running `rake test`, you might see something like:
+```
+  1) Failure:
+  UserStoriesTest#test_visit_/ [/my_app/test/integration/user_stories_test.rb:96]:
+  Expected response to be a <success>, but was <302>
+```
+
+This indicates that this url was redirected
+
+You can then go to the production site, and verify that visit always results in a redirect, and modify the test accordingly.  Also, you can add checks against the page content/type, perhaps by adding an `assert_content :index`, or whatever is appropriate.  Also, the auto-generated name is a placeholder; rename it, once you understand the context.
+
+After the test is cleaned up, it may look more like this:
+
+```ruby
+test "visit home url, ensure it redirects to index" do
+  get '/'
+  assert_response :redirect 
+  assert_template :index
+end
+```
+
+Once you have this one test perfected, you will have the most visited part of the site tested, and you can move to the next test.  
+
+
+Wow, that was easy, wasn't it?  Unfortunately, building tests on a legacy application is rarely a simple matter, and you may have to go prospecting deep into the application to make a test work.  Hopefully, using logs as a guide will help to create the most informative, useful tests first, and give us an idea of what setup requirements we will need for many other tests.
+
+#### Example 2: Url requiring a login
+
+This example walks through the process of building a test with several setup requirements. I'm going to break the setup into separate methods, which I can hopefully be reused other tests.
+
+This test, as generated, doesn't work:
+```ruby
+test "visit /user/profile/:id" do
+  skip
+  #this url was visited 424 times
+  get '/user/profile/:id'
+  assert_response :success
+end
+```
+
+after taking a look in `app/views/users/profile.erb`, looking at `/app/controllers/user_controller.rb`, examining the User model, and logging in to the website to browse this url, we find these setup requirements:
+1. The ability to login before running this test
+2. The link to this page is found on root page, which is what the first test covers. For consistency, we want to verify that the root page has this link.
+
+Step two feels easier, so let's start with that, by turning the test from example one into a private method called 'visit_home', so we can call it as needed.  
+
+```ruby
+private
+
+def visit_home
+  get_via_redirect '/'
+  assert_response :success
+  assert_template :index
+end
+```
+
+then change our old test to match, so we can see that visit_home works correctly.  Tests testing tests, cats and dogs living together, mass hysteria!  But hey, it lets us call 'visit_home', and have confidence that it works, before we embed it in another test.
+
+rewritten test from example 1:
+
+```ruby
+test "visit home url, ensure it redirects to index" do
+  visit_home
+end
+```
+
+Note that these tests are a stopgap.  Some of them might turn out to be useful, but many of them will be too brittle for the long term.  But they can provide a bridge that allows you to proceed with an upgrade, to preserve the current functionality of the site, and to exercise the site enough to generate deprecation warnings.
+
+Now for step 1.  We need a private method called 'login', as well as the relevant fixture data.  The Users model shows that our fixture needs to contain a username at least 7 characters long, a password, a valid email, and a date that is in the future, for the 'expires_at' value.
+
+The log reveals that logging in is executed as a `post` to `/user/login`, which passes this data: 
+
+    `user: { login: <login> , password: <p> }`
+
+At this point, it might be more useful to divert from writing these tests, to writing tests for the Users model, or at least create a to-do item somewhere, noting that the users model should have tests that ensure we come back to testing the things we discovered.
+
+
+Additionally the database turns out to contain hashed passwords, so we dig into the User model, and find the command used to hash a password:
+Digest::SHA1.hexdigest(password)
+
+
+We now have enough information to create our fixture, which looks like this:
+```
+good888:
+  login: good888
+  password: <%= Digest::SHA1.hexdigest("pw") %>
+  physician_name: good
+  email: good@email.com
+  expires_at: <%= (Date.today + 5.days).to_s(:db) %> 
+```
+
+So, now we can try to log in from our test.  We should put login in its own method, but for now, let's just give this a shot as-is:
+
+```ruby
+test "visit /user/profile/:id" do
+  visit_home
+  post '/user/login', user: { login: 'admin888' , password: 'pw' }
+  follow_redirect!
+  assert_response :success
+  assert_equal '/', path
+  get "/user/profile/#{users(:good888).id}"
+  assert_response :success
+end
+```
+
+We run it, it seems to work, so now we can add this line, to check for the profile link on the home page:
+
+    assert_select 'a[href=?]', "/user/profile/#{users(:good888).id}", {count: 1}
+
+Then do a little refactoring, to break login into a reusable method, and finalize this test:
+
+private login method:
+```ruby
+def login(login, p)
+  post '/user/login', user: { login: login , password: p }
+  follow_redirect!
+  assert_response :success
+  assert_equal '/', path
+end
+```
+
+**The 'login' method could be useful in many places.  If you find yourself needing it elsewhere, push it up into 'test/test_helper.rb', to make it available in your model/view/controller tests.**
+
+cleaned up test:
+```ruby
+test "login, make sure user profile link is available, and that we can visit it" do
+  visit_home
+  login('good888','pw')
+  user_id=users(:good888).id.to_s
+  assert_select 'a[href=?]', "/user/profile/#{user_id}", {count: 1}¬
+  get "/user/profile/#{user_id}"
+  assert_response :success
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tnordloh/your_legacy_tests. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+count defaults to 25, and controls the number of tests generated.
+
+Results are generated on stdout, for maximum flexibility on where the tests are placed in the Rails application.
+
+Here are some examples on how to modify the generated templates, for your application.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/setup

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

data/exe/tests_via_sumo

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/sumo_sum"
+
+require 'getoptlong'
+
+opts = GetoptLong.new(
+  ['--help','-h', GetoptLong::OPTIONAL_ARGUMENT],
+  ['--source_category','-s', GetoptLong::OPTIONAL_ARGUMENT],
+  ['--count','-c', GetoptLong::OPTIONAL_ARGUMENT],
+)
+
+source_category = "*"
+count           = 25
+
+opts.each do |opt,arg|
+  case opt
+  when '--help'
+    puts <<-EOF
+    usage: #{ __FILE__ } [--help or -h] [-c or --count <count>]
+           [-s or --source_category <category>]
+
+    Specify number of tests returned, with most visited first
+    Defaults to 25:
+
+    #{ __FILE__ } -c, --count integer:
+
+    specify a source category in the sumo query.
+    defaults to "*":
+
+    #{ __FILE__ } -s, --source_category [source_category]:
+
+    show help:
+    #{ __FILE__ } -h, --help
+
+    EOF
+    exit 0
+  when '--source_category'
+
+    source_category=arg
+
+  when '--count'
+    raise "count not an integer" unless arg[/[0-9]+/].size == arg.size
+    count = arg.to_i
+  end
+end
+
+SumoSum.process(source_category, count)
+

data/lib/sumo_sum/constants.rb

@@ -0,0 +1,23 @@
+TOP_CLASSES=' started |' +
+  ' parse regex "\s(?<protocol>.+)\s\"(?<pre>/.*)\" "|' +
+  'where !(pre matches  "*png*")|' +
+  'where !(pre matches "*/assets*")|' +
+  'where !(pre matches "*page=*" ) |' +
+  "split pre delim='/' extract 2 as class, 3 as method, 4 as id |" +
+  "split class delim='?' extract 1 as class |" +
+  "split method delim='?' extract 1 as method |" +
+  'replace(method,"9","0") as method |' +
+  'replace(method,"8","0") as method |' +
+  'replace(method,"7","0") as method |' +
+  'replace(method,"6","0") as method |' +
+  'replace(method,"5","0") as method |' +
+  'replace(method,"4","0") as method |' +
+  'replace(method,"3","0") as method |' +
+  'replace(method,"2","0") as method |' +
+  'replace(method,"1","0") as method |' +
+  'replace(method,"00000","0") as method |' + 
+  'replace(method,"0000","0") as method |' + 
+  'replace(method,"000","0") as method |' + 
+  'replace(method,"00","0") as method |' + 
+  'replace(method,"0",":id") as method |' + 
+  'count_frequent class,method,protocol'

data/lib/sumo_sum/sumo_sum.rb

@@ -0,0 +1,65 @@
+require 'Sumo'
+require 'Time'
+
+require_relative './constants'
+require_relative '../../lib/testing_your_legacy/testing_your_legacy'
+require_relative '../../lib/testing_your_legacy/discover'
+
+module SumoSum
+  class SumoSum
+
+    def initialize(source_category= "*",count=25)
+      @source_category = source_category
+      @count           = count
+    end
+
+    attr_reader :source_category, :count
+
+    def sum_with_source
+      "_sourceCategory=" + source_category + " " + TOP_CLASSES
+    end
+
+    def top_visits
+      @top_visits ||= get_records
+    end
+
+    def get_records()
+      query = Sumo.search(query:  sum_with_source,
+                           from: "#{days_ago}",
+                             to: "#{Time.now.utc.iso8601.chop}",
+                      time_zone: 'UTC'
+                     )
+
+      until query.status['state'] == "DONE GATHERING RESULTS" do
+        STDERR.puts "gathering results -- sleeping 2 seconds:records so far: #{query.status["recordCount"]}"
+        sleep 2
+      end
+      query.records
+    end
+
+    def each
+      top_visits.first(count).each do |record|
+        yield TestingYourLegacy::LogEntry.new(get_link(record),
+                                              record["protocol"],
+                                              record["_approxcount"])
+      end
+    end
+
+    def days_ago(days=90)
+      ninety_days_ago_in_seconds=60*60*24*days
+      (Time.now - ninety_days_ago_in_seconds).utc.iso8601.chop
+    end
+
+    def get_link(record)
+      "/" +
+        ["class","method"].map do |field|
+        record[field]
+        end
+      .reject {|field|
+        field==""
+      }
+      .join("/")
+    end
+  end
+end
+

data/lib/sumo_sum.rb

@@ -0,0 +1,14 @@
+require_relative "testing_your_legacy/discover"
+require_relative "sumo_sum/sumo_sum"
+
+module SumoSum
+  def self.process(source_category,count)
+    list = SumoSum.new(source_category,count)
+    discovers = TestingYourLegacy::Discover.new(list)
+
+    discovers.each do |r|
+      puts discovers.generate_method(r) + "\n"
+    end
+
+  end
+end

data/lib/testing_your_legacy/discover.rb

@@ -0,0 +1,33 @@
+require_relative './testing_your_legacy'
+require 'erb'
+
+module TestingYourLegacy
+  class Discover
+    def initialize(logs)
+      @logs=logs
+    end
+
+    def each
+      @logs.each do |record|
+        yield record
+      end
+    end
+
+    def generate_method(record)
+      @record = record
+      ERB.new(read_template('method_template.erb'))
+         .result(binding())
+    end
+
+    def generate_test(record)
+      @record = record
+      ERB.new(read_template('test_template.erb'))
+         .result(binding())
+    end
+
+    def read_template(template)
+      File.read(File.join(File.dirname(__FILE__), template))
+    end
+
+  end
+end

data/lib/testing_your_legacy/method_template.erb

@@ -0,0 +1,6 @@
+def <%= @record[:url].gsub("/","_") %>
+  #this url was visited <%= @record[:visits] %> times
+  <%= @record[:protocol].downcase %> <%= @record[:url] %>
+  assert_response :success
+end
+

data/lib/testing_your_legacy/test_template.erb

@@ -0,0 +1,6 @@
+test "visit <%= @record[:url] %>" do
+  skip
+  #this url was visited <%= @record[:visits] %>
+  <%= @record[:protocol].downcase %> <%= @record[:url] %>
+  assert_response :success
+end

data/lib/testing_your_legacy/testing_your_legacy.rb

@@ -0,0 +1,3 @@
+module TestingYourLegacy
+  LogEntry=Struct.new(:url,:protocol,:visits)
+end

data/lib/testing_your_legacy/version.rb

@@ -0,0 +1,3 @@
+module YourLegacyTests
+  VERSION = "0.1.0"
+end

data/lib/testing_your_legacy.rb

@@ -0,0 +1 @@
+require_relative 'testing_your_legacy/discover'

data/testing_your_legacy.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'testing_your_legacy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "testing_your_legacy"
+  spec.version       = YourLegacyTests::VERSION
+  spec.authors       = ["Timothy Nordloh"]
+  spec.email         = ["tnordloh@gmail.com"]
+
+  spec.summary       = %q{Use Sumo Logic to generate tests for a Rails application, based on most frequently visited urls }
+  spec.homepage      = "https://github.com/tnordloh/testing_your_legacy"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    #spec.metadata['allowed_push_host'] = "'http://mygemserver.com'"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: testing_your_legacy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Timothy Nordloh
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- tnordloh@gmail.com
+executables:
+- tests_via_sumo
+extensions: []
+extra_rdoc_files: []
+files:
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/setup
+- exe/tests_via_sumo
+- lib/sumo_sum.rb
+- lib/sumo_sum/constants.rb
+- lib/sumo_sum/sumo_sum.rb
+- lib/testing_your_legacy.rb
+- lib/testing_your_legacy/discover.rb
+- lib/testing_your_legacy/method_template.erb
+- lib/testing_your_legacy/test_template.erb
+- lib/testing_your_legacy/testing_your_legacy.rb
+- lib/testing_your_legacy/version.rb
+- testing_your_legacy.gemspec
+homepage: https://github.com/tnordloh/testing_your_legacy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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.2.5
+signing_key: 
+specification_version: 4
+summary: Use Sumo Logic to generate tests for a Rails application, based on most frequently
+  visited urls
+test_files: []