brpm_content 0.1.16

data/modules/framework/lib/version_control/svn.rb

@@ -0,0 +1,221 @@
+require 'uri'
+
+# Base class for working with Subversion
+class Svn
+  
+  # Initializes an instance of the class
+  #
+  # ==== Attributes
+  #
+  # * +svn+ - path to the svn executable
+  # * +params+ - params hash
+  # * +options+ - hash of options includes:...
+  #   url - url for svn repository...
+  #   base_path - path for the local repository...
+  #   username - repository user username...
+  #   password - repository user password...
+  #   verbose - true for verbose output (default = false)...
+  #   rebase - starting path for checkouts...
+  #   simulate - simulate command - echo it (default = false)...
+  #   prerun_lines - pass any text to run before svn (such as env variables)...
+  #   command_options - options to pass on command line e.g. --non-interactive
+  #
+  def initialize(svn, params, options)
+    self.extend Utilities
+    @url = required_option(options,"url")
+    @base_path = required_option(options,"base_path")
+    user = get_option(options,"username")
+    @password = get_option(options,"password")
+    @verbose = get_option(options,"verbose", false)
+    @prerun = get_option(options, "prerun_lines")
+    @command_options = get_option(options, "command_options")
+    @command_options += " --non-interactive" unless @command_options.include?("non-interactive")
+    @rebase = get_option(options, "rebase")
+    @rebase =  @url.split("/")[-1] if @rebase == ""
+    @simulate = get_option(options,"simulate", false)
+    make_credential(user, @password)
+    @svn = svn
+  end
+ 
+  # Parses a complex svn uri into parts
+  #
+  # ==== Attributes
+  #
+  # * +svn_url+ - svn url, like this:...
+  # https://user:password@host:port/path/path[#revision]...
+  # https://user:password@svn.nam.nsroot.net:9050/svn/16667/appreldep/RLM/artifacts/CATE[7777777]
+  # * +reset_values+ - resets the svn object parameters host, password etc from url (default=false)
+  #
+  # ==== Returns
+  #
+  # * parse result, like this:...
+  # {"uri_result" => URIGemResult, "revision" => ""}
+  def parse_uri(svn_uri, reset_values = false)
+    result = {"uri_result" => nil, "revision" => ""}
+    k = svn_uri.scan(/\[.*\]/)
+    result["revision"] = k[0].gsub("[","").gsub("]","") if k.size > 0
+    rev = k.size > 0 ? "[#{result["revision"]}]" : "__ZZZ__"
+    parts = URI.parse(svn_uri.gsub(rev,""))
+    result["uri_result"] = parts
+    if reset_values
+      @url = "#{parts.scheme}://#{parts.host}:#{parts.port}#{parts.path}"
+      make_credential(parts.user, parts.password) unless parts.password.nil?
+    end
+    result
+  end
+
+  # Performs an svn checkout
+  #
+  # ==== Attributes
+  #
+  # * +init+ - true to initilize the checkout and local repo
+  # ==== Returns
+  #
+  # * command output
+  def checkout(init = false)
+    FileUtils.cd(@base_path, :verbose => true)
+    if init
+      cmd = "#{@svn} checkout #{@url} #{@rebase}  #{@credential} #{@command_options}"
+    else
+      cmd = "#{@svn} checkout  #{@command_options}"
+    end
+    process_cmd(cmd)
+  end
+
+  # Performs an svn export
+  #
+  # ==== Attributes
+  #
+  # * +revision+ - revision to export (options - defaults to latest)
+  # ==== Returns
+  #
+  # * command output
+  def export(target = "", revision = "")
+    url_items = URI.parse(@url)
+    target = url_items.path if target == ""    
+    cmd_options = @command_options
+    cmd_options += " --no-auth-cache --trust-server-cert --force" if cmd_options == " --non-interactive"
+    base_cmd = "#{@svn} export #{@credential} #{@command_options} #{@url}"
+    FileUtils.cd(@base_path, :verbose => true)
+    if revision == ""
+      cmd = "#{base_cmd} ."
+    else
+      cmd = "#{base_cmd} -r #{revision} ."
+    end
+    process_cmd(cmd)
+  end
+
+  # Performs an svn checkout
+  #
+  # ==== Returns
+  #
+  # * command output
+  def get
+    cmd = "#{@svn} checkout --non-interactive"
+    process_cmd(cmd)
+  end
+  
+  # Performs an svn commit
+  #
+  # ==== Attributes
+  #
+  # * +message+ - commit string
+  # ==== Returns
+  #
+  # * command output
+  def commit(message = "Automation pushed changes")
+    # /usr/bin/svn commit . -m "PSENG-0000 Adding PSENG files"
+    cmd = "#{@svn} commit . -m \"#{message}\""
+    process_cmd(cmd)
+  end
+  
+  # Performs an svn tag
+  #
+  # ==== Attributes
+  #
+  # * +source_path+ - path in repo to tag
+  # * +tag_name+ - name for tag
+  # * +message+ - message to add to tag
+  #
+  # ==== Returns
+  #
+  # * command output
+  def tag(source_path, tag_name, message)
+    ipos = @url.index("trunk")
+    raise "Cannot locate trunk path" if ipos.nil?
+    tag_path = @url[0..ipos] + "tags/" + tag_name
+    cmd = "#{@svn} copy #{source_path} #{tag_path} -m \"#{message}\""
+    process_cmd(cmd)
+  end
+  
+  # Performs an svn status
+  #
+  # ==== Returns
+  #
+  # * command output
+  def status
+    process_cmd("#{@svn} status")
+  end
+  
+  # Adds any new files in the local repo to the svn commit list
+  #
+  # ==== Attributes
+  #
+  # * +exclude_regex+ - regex to filter add files (file !=~ filter)
+  #
+  # ==== Returns
+  #
+  # * command output
+  def add_files(options = {})
+    result = status
+    msg = ""
+    exclude = get_option(options,"exclude_regex")
+    result.split("\n").each do |item|
+      if item.start_with?("?")
+        file = item.gsub("?","").strip
+        cmd = "#{@svn} add #{file}"
+        if exclude == ""
+          msg += process_cmd(cmd)
+        else
+          msg += process_cmd(cmd) if file =~ /#{exclude}/
+        end
+        res = `#{cmd}`
+      end
+    end
+    "#{result}\n#{msg}"
+  end
+
+  private        
+  
+  def process_cmd(cmd)
+    goto_base
+    cmd = "#{@prerun} && #{cmd}" unless @prerun == ""
+    res = execute_shell(cmd) unless @simulate
+    BrpmAuto.log cmd.gsub(@password,"-private-") if @verbose || @simulate
+    @simulate ? "ok" : display_result(res)
+  end
+  
+  def goto_base
+    @pwd = FileUtils.pwd
+    goto_path = @base_path #@rebase != "" ? File.join(@base_path,@rebase) : @base_path
+    FileUtils.cd(goto_path, :verbose => true) if @verbose
+    FileUtils.cd(goto_path) unless @verbose
+  end
+
+  def svn_errors?(output)
+    svn_terms = ["403 Forbidden", "SSL error code", "moorrreee"]
+    found = output.scan(/#{svn_terms.join("|")}/)
+    found.size > 0
+  end
+  
+  def make_credential(user, password)
+    if user.to_s != "" && password.to_s != ""
+      @credential = " --username #{user} --password #{password}"
+    else
+      @credential = ""
+    end
+  end
+
+end
+
+

data/modules/framework/log.html

@@ -0,0 +1,39 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <script src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
+  <script type="text/javascript">
+
+    $(document).ready(function() {
+
+      function getURLParameter(name) {
+        return decodeURIComponent((new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)').exec(location.search)||[,""])[1].replace(/\+/g, '%20'))||null
+      }
+
+      function functionToLoadFile(){
+        jQuery.get('/brpm/automation_results/' + getURLParameter('request') + '.log', function(data) {
+          mustScroll = false;
+
+          if($(window).scrollTop() + $(window).height() == $(document).height()){
+            mustScroll = true;
+          }
+
+          $('#text-file-container').html(data);
+
+          if(mustScroll){
+            window.scrollTo(0,document.body.scrollHeight);
+          }
+
+          setTimeout(functionToLoadFile, 2000);
+        });
+      }
+
+      setTimeout(functionToLoadFile, 10);
+    });
+
+  </script>
+</head>
+<body>
+<pre id="text-file-container"></pre>
+</body>
+</html>

data/modules/framework/tests/all_params_spec.rb

@@ -0,0 +1,116 @@
+require_relative "spec_helper"
+
+describe 'All params' do
+  before(:each) do
+    cleanup_request_params
+  end
+
+  it 'should get a param from the param store' do
+    input_params = get_default_params
+    input_params["key1"] = "value1"
+
+    BrpmAuto.setup(input_params)
+    all_params = BrpmAuto.all_params
+
+    expect(all_params).to have_key("key1")
+    expect(all_params["key1"]).to eql("value1")
+  end
+
+  it 'should get a param from the request_param store' do
+    input_params = get_default_params
+    input_params["key1"] = "value1"
+
+    BrpmAuto.setup(input_params)
+    all_params = BrpmAuto.all_params
+
+    expect(all_params).to have_key("key1")
+    expect(all_params["key1"]).to eql("value1")
+  end
+
+  it 'should get a param by the get method' do
+    input_params = get_default_params
+    input_params["key1"] = "value1"
+
+    BrpmAuto.setup(input_params)
+    all_params = BrpmAuto.all_params
+
+    expect(all_params).to have_key("key1")
+    expect(all_params.get("key1")).to eql("value1")
+  end
+
+  it 'should raise an error when trying to add a param using []=' do
+    BrpmAuto.setup(get_default_params)
+    all_params = BrpmAuto.all_params
+
+    expect{ all_params["key1"] = "value1" }.to raise_exception(RuntimeError)
+  end
+
+  it 'should add a param by the add method to the params store' do
+    input_params = get_default_params
+
+    BrpmAuto.setup(input_params)
+    all_params = BrpmAuto.all_params
+
+    all_params.add("key1", "value1", "params")
+
+    expect(all_params).to have_key("key1")
+    expect(all_params["key1"]).to eql("value1")
+    expect(all_params.count).to eql(get_default_params.count + 1)
+
+    expect(BrpmAuto.params.count).to eql(all_params.count)
+
+    request_params = get_request_params
+    expect(request_params.count).to eql(0)
+  end
+
+  it 'should add a param by the add method to the request_param store' do
+    input_params = get_default_params
+    BrpmAuto.setup(input_params)
+    all_params = BrpmAuto.all_params
+
+    all_params.add("key1", "value1", "json")
+
+    expect(all_params).to have_key("key1")
+    expect(all_params["key1"]).to eql("value1")
+    expect(all_params.count).to eql(input_params.count + 1)
+
+    expect(BrpmAuto.params.count).to eql(all_params.count - 1)
+
+    request_params = get_request_params
+    expect(request_params.count).to eql(1)
+  end
+
+  it 'should find or add a param to the params store' do
+    input_params = get_default_params
+    input_params["key1"] = "value1"
+
+    BrpmAuto.setup(input_params)
+    all_params = BrpmAuto.all_params
+
+    expect(all_params.find_or_add("key1", "value1-bis", "params")).to eql("value1")
+    expect(all_params.count).to eql(input_params.count)
+
+    expect(all_params.find_or_add("key2", "value2", "params")).to eql("value2")
+    expect(all_params.count).to eql(input_params.count + 1)
+    expect(all_params["key2"]).to eql("value2")
+  end
+
+  it 'should find or add a param to the request_params store' do
+    input_request_params = {}
+    input_request_params["key1"] = "value1"
+    set_request_params(input_request_params)
+
+    input_params = get_default_params
+    BrpmAuto.setup(input_params)
+    all_params = BrpmAuto.all_params
+
+    expect(all_params.find_or_add("key1", "value1-bis", "json")).to eql("value1")
+    expect(all_params.count).to eql(input_params.count + 1)
+
+    expect(all_params.find_or_add("key2", "value2", "json")).to eql("value2")
+    expect(all_params.count).to eql(input_params.count + 2)
+    expect(all_params["key2"]).to eql("value2")
+  end
+end
+
+

data/modules/framework/tests/brpm_auto_spec.rb

@@ -0,0 +1,84 @@
+require_relative "spec_helper"
+
+describe 'BRPM automation framework' do
+  before(:all) do
+    setup_brpm_auto
+  end
+
+  describe 'privatize' do
+    it 'should hide a sensitive string' do
+      result = BrpmAuto.privatize("The password should be replaced here: MySecret, and also here:MySecret! ", "MySecret")
+
+      expect(result).not_to include("MySecret")
+      expect(result).to include("The password should be replaced here: ")
+      expect(result).to include(", and also here:")
+      expect(result).to include("! ")
+    end
+
+    it 'should hide an array of sensitive strings' do
+      privatized_string = BrpmAuto.privatize("The password should be replaced here: MySecret, and also here:MyOtherSecret! ", [ "MySecret", "MyOtherSecret" ])
+
+      expect(privatized_string).not_to include("MySecret")
+      expect(privatized_string).not_to include("MyOtherSecret")
+      expect(privatized_string).to include("The password should be replaced here: ")
+      expect(privatized_string).to include(", and also here:")
+      expect(privatized_string).to include("! ")
+    end
+  end
+
+  describe 'substitute_tokens' do
+    it 'should replace a token' do
+      params = {}
+      params["application"] = "E-Finance"
+      result = BrpmAuto.substitute_tokens("The application is called rpm{application}", params)
+
+      expect(result).to eq("The application is called E-Finance")
+    end
+
+    it 'should replace a set of tokens' do
+      params = {}
+      params["application"] = "E-Finance"
+      params["component"] = "EF - java calculation engine"
+      params["component_version"] = "1.2.3"
+      result = BrpmAuto.substitute_tokens("The application is called rpm{application} and has component rpm{component} with version number rpm{component_version}", params)
+
+      expect(result).to eq("The application is called E-Finance and has component EF - java calculation engine with version number 1.2.3")
+    end
+
+    it 'should replace a set of nested tokens' do
+      params = {}
+      params["application"] = "E-Finance"
+      params["component"] = "EF - java calculation engine"
+      params["component_version"] = "1.2.rpm{component_version_revision}"
+      params["component_version_revision"] = "3"
+      result = BrpmAuto.substitute_tokens("The application is called rpm{application} and has component rpm{component} with version number rpm{component_version}", params)
+
+      expect(result).to eq("The application is called E-Finance and has component EF - java calculation engine with version number 1.2.3")
+    end
+  end
+
+  describe 'dos_path' do
+    it 'should convert a path from the UNIX to the Windows format' do
+      result = BrpmAuto.dos_path("C/windows/path")
+
+      expect(result).to eq("C:\\windows\\path")
+    end
+  end
+
+  describe 'execute_shell' do
+    it 'should execute a command successfully' do
+      result = BrpmAuto.execute_shell("echo Hello")
+
+      expect(result["status"]).to eql(0)
+      expect(result["stdout"]).to eql("Hello\n")
+    end
+
+    it 'should return with a non-zero status when passing a bad command' do
+      result = BrpmAuto.execute_shell("xxxx")
+
+      expect(result["status"]).not_to eql(0)
+    end
+  end
+end
+
+