JJ the Engineer

How to resolve bitbucket merge conflicts to master from a release branch?

2020-07-22T14:40:00.004-04:00

This happens a fair amount on bitbucket, and I needed a reminder on how to resolve the conflicts without merging the branch into my feature branch which would cause history issues.

Steps

$ git checkout master
$ git checkout -b resolve-conflicts-branch

You want to branch off of master to see the conflicted changes

$ git pull origin release/branch-id

This should move the changes you wanted to go into master into the newly created branch

All the merge conflicts should appear, now sort them out
git push -u origin resolve-conflicts-branch

Push to remote so you can create a PR

Create a pull request from source resolve-conflicts-branch to release/branch-id
Review and use merge commit -no-ff strategy.

This is useful if you are trying to make a pull request to master, but there are merge conflicts that need to be resolved. In your pull request, you might not see any diff's, but the history change and conflict resolution is there. Merge it into the release branch, and that should resolve your merge conflicts in the pull request that is going into master.

Notes

If you apply this method for a merge conflict resolution using develop, you will want to open a PR from resolve-conflicts-branch to develop instead of the release/branch-id since develop will have activity that master wont.

Enforcing Full Flex Rules using Stylelint for IE11 Support

2019-10-16T08:58:00.001-04:00

When using Flex, we discovered we needed to write out the full rules to support IE11. Otherwise, IE11 will do some funky things with the styling, and cause a bunch of broken modals for us. This was listed in flexbug #8, and instead of remembering that we had to do it - we figured it made sense to just enforce it at the linting level. It's pretty straight forward, but it did take a while to figure out as we weren't super familiar with custom rules.

This is our example .stylelintrc - We added the flex rule under "declaration-property-value-whitelist"

{
"extends": "stylelint-config-standard",
"rules": {
"color-hex-case": "upper",
"color-hex-length": "long",
"at-rule-no-unknown": null,
"declaration-property-value-whitelist": {
"flex": ["/^\\S+\\s+\\S+\\s+\\S+$/"]
},
}
}

To make your life even easier - here are some simple translations.
Here is a great guide from css tricks.

flex:none should be “flex: 0 0 auto”
flex:auto should be “flex: 1 1 auto”
flex:1 should be “flex: 1 1 0%”

Hope this makes life easier for you!

Testing for reliability of a Cypress test

2019-10-01T07:58:00.001-04:00

Overview

When writing automation tests, you want to ensure the test is reliable, and doesn't provide false positives for you and your team. This is especially important when the test makes it into the continuous integration(CI) pipeline. For Cypress, we do two things to try and address reliability.

The first is to ensure the test can run x number of times without breaking.
The second is for end-to-end(e2e) tests that require a full run-through, but the backend might be a little bit flaky.

Method 1

I usually run the tests I write a few times before submitting it for a pull request to go into the main CI pipeline. Since Cypress tests are written in javascript, I wrap the entire test into a loop! I run this test 2-3 times to ensure it passes consistently. I found that if you increase the number, the browser will crash sometimes. Make sure you remove this after validating that the test is reliable!

var i = 0;

for (i = 0; i < 20 ; i++) {   

  describe('Is my test actually reliably?', () => {

    it('should do that thing', function() {

      // the new test I want to validate is working

    })

  })

}

Method 2

The second method has been written up before, but its basically retrying only failed tests to account for odd backend instability. You can view the write up here.

Hopefully some of these tips and tricks will help you on your automation journey. Good luck!

Quick and dirty way to fix flakiness in Cypress tests

2019-09-20T09:34:00.001-04:00

Overview of the problem

Frontend test automation can be fairly tricky when attempting to do full end to end coverage. People want 100% flake free tests, and only act on problems that are actionable.

If you've ever written an end to end test, you've probably had instances where a particular area of your app will have some odd flakiness to it. The test will run and succeed 95% of the times, but when it fails randomly due to a backend issue, the solution may very well be to re-run it until it passes. The simplicity of a person re-running a failing test until it passes is what causes error numbness, and frustration for having to do it. There are instances where the backend may not fully respond in time even if you put in reasonable async waits, or the backend is being flaky which can cause frontend tests to fail.

The goal of this solution is to make it so that when failures do occur, the failure is actionable. You want to cultivate a culture of reacting quickly to failures, and not have the solution be that a developer goes into the CI build to rerun the build until it passes.

[Quick and dirty temporary solution]

There is a neat temporary plugin that you can install to address this issue in the short term until there's a more permanent solution by Cypress themselves. It's an npm package named "cypress-run" that essentially forwards all arguments you already use when running "cypress run". I'll provide the instructions in yarn, as there are instructions for npm in the package link.

Full link - https://www.npmjs.com/package/cypress-run
Package description in case it ever disappears

Hopefully this module is short-lived. Right now it add retry support for parallel runs. It should work just like cypress run by forwarding all arguments, just using the Cypress Module API to support parallelization.

It uses this gist and turns it into a module and adds support for cypress run arguments: https://gist.github.com/Bkucera/4ffd05f67034176a00518df251e19f58#file-cypress-retries-js

This modules also adds retries regardless of --parallel or --record flags and doesn't need the Cypress Dashboard.

Installation of cypress-run

1. In your command line

yarn add --dev cypress-run

2. In your package.json

Update your "cypress run" command to "cypress-run"

It's that simple!

I've looked into several solutions, and the most noteworthy alternative is "cypress-plugin-retries" which is a bit more fully featured where it will only re-run the specific test that fails. I prefer re-running the entire test file if it fails.

How to synchronize your branch on bitbucket

2019-07-03T13:07:00.000-04:00

There are times when I am unable to "Sync now" on bitbucket when it is several commits behind, and bitbucket will prompt me to resolve some conflicts from the command line. Here are the steps I take to move my "master" branch forward so it is not out of sync with my main "develop" branch.

Command Line (Will need write permissions)

Bitbucket will provide the commit hash for DETACHED HEAD. You can also find the latest commit hash using git log.

git checkout master
git reset --soft <latest commit hash in your `git log`>
git merge --squash --strategy-option theirs remotes/origin/develop
git commit -m "Move master forward to be in sync with develop"
git push -u --force origin master

Bitbucket Branch Web UI

Navigate to the "master" branch in your repository
Click on "Sync now"
You should see a commit message of "Merged develop into master" and you should be all set!

How to enter passphrase only once when operating in the terminal with ssh on macOS

2019-06-17T15:50:00.002-04:00

If you only want to enter in your passphrase once while you are working in the terminal with git, you need to add the key to your ssh-agent. This should be valid until you reboot your machine.

ssh-add ~/.ssh/id_rsa

Now, when you pull, it should do so without prompting for your passphrase. I primarily do this when I have written convenience scripts to run between branches.

How to merge and squash a feature branch into master

2019-06-13T08:13:00.002-04:00

Often times when I am working on a feature branch, I want one commit to go into develop or master. For this example, we will demonstrate how to merge a feature branch into master with a single squashed commit.

First, pull the branch you want to merge into. In this case, it is master. I then squash merge the feature branch that I want into master.

git checkout master
git pull
git merge --squash feature/branch

Review your changes, commit, and push to master

git status
git commit -m "describe your commit"
git push origin master

That's all there is to it. Good luck!

Clean up local git branches

2019-06-10T10:39:00.000-04:00

Here is a quick way to remove a bunch of local branches without deleting "develop" or "master". The only caveat is it doesn't delete anything similar to "develop" or "master", so if you named a branch "banana_develop", it won't delete that branch.

git branch | grep -v "develop" | grep -v "master" | xargs git branch -D

grep -v means an inverted match - get all the branches and ignore "develop" and "master" branches.

xargs git branch -D will do the dirty work of deleting all LOCAL branches. This will not affect remote branches.

You may want to run the snippet below first to verify you know what is being deleted.

git branch | grep -v "develop" | grep -v "master"

Installing Visual Studio Code On The Mac

2018-06-13T10:01:00.002-04:00

There are several ways to install Visual Studio Code on the Mac, but I think the best way to do it is via brew cask. The official site offers a downloadable zip for MacOS, and this isn't difficult to do, but if you want auto-updates, I highly recommend using brew cask. I've recently started using MacOS for work, so I am documenting useful tidbits for other developers who might be starting out.

If you have brew already installed, installing Visual Studio Code should be a breeze!
Simple type out the following command in the terminal.

brew cask install visual-studio-code

Once the prompt responds with successfully installed, bring up your spotlight search and look for visual studio code to start the program!

Adding Static Analysis And Linting For Bash Scripts

2018-05-15T19:23:00.001-04:00

For a long time, I wondered if there was a tool for keeping coding styles and best practices when coding in Bash. After a brief search, I finally found two tools that would help keep our bash scripts in check. This is especially important when working in teams that code heavily in bash, and is super helpful if integrated into a CI/CD pipeline.

Static Analysis

For Static Analysis, I found that ShellCheck did everything I needed it to do. It's an incredibly easy to setup tool that took only a few minutes to install. From the site, ShellCheck aims to do the following:

To point out and clarify typical beginner's syntax issues that cause a shell to give cryptic error messages.

To point out and clarify typical intermediate level semantic problems that cause a shell to behave strangely and counter-intuitively.

To point out subtle caveats, corner cases and pitfalls that may cause an advanced user's otherwise working script to fail under future circumstances.

Linting

For Linting, I wanted something that would enforce styles like making sure things were tabbed consistently, if/else statements were written in a consistent format. I found bashate which helped to enforce standards in Bash like PEP8 would for python. Installation was also super simple, all that was required was a quick `pip install bashate` or `pipenv install bashate` for my local command line. The installation README displays all of the rules it enforces, but here I would like to list a few that I liked.

E001: check that lines do not end with trailing whitespace

E002: ensure that indents are only spaces, and not hard tabs

E003: ensure all indents are a multiple of 4 spaces

E004: file did not end with a newline

E005: file does not begin with #! or have a .sh prefix

Tool Integration

Integrating the tools is relatively simple and the tool READMEs provide guides on how to do so. Overall, you need to run the command line version of the tool and the script that you want to analyze. `shellcheck example.sh`, or ideally you'd want to add a script that traverses the folder structure, and retrieves all shell scripts to be analyzed. From there, you might want to also handle exit codes if you want your pipeline to fail when errors or warnings are found.

RESTinstance - How to Set Headers

2018-05-15T08:25:00.000-04:00

Tip of the day

Setting headers in the RESTinstance library was surprisingly difficult for me at first, but it's actually quite simple. Initially, I had been passing in an entire JSON object with multiple values as you would normally for a header like you would in Postman, but in this case you only need to pass in a key value pair one at a time.

Let me demonstrate with an example of how to sign in as a user, retrieve the JWT token that gets returned, and reusing that JWT token so that I have authorized access to make a `GET` call to query the users list.

   POST      /auth/login   body={"email":"${username}","password":"${password}"}  
   ${jwt_token} = String   response body token    
   Set Headers   {"Authorization":"JWT ${jwt_token}"}  
   GET           /users

If you wanted to add more headers, you can just do the following...

   Set Headers   {"Authorization":"JWT ${jwt_token}"}  
   Set Headers   {"Accept-Encoding":"gzip"}

And that's all there is to Setting Headers in RESTinstance! Good luck!

RESTinstance - How to access my response fields

2018-05-12T17:57:00.002-04:00

Tip of the day

Often times when we are testing APIs, we need to validate specific response fields or reuse them in some fashion. This could be reusing an authentication token after signing in, or just validating that the response returned "potatoes" in the field "delicious". Not the greatest example, but you get the point. In this article, I hope to show you how to do field validation using the RESTinstance library for Robotframework.

Here is a breakdown of an example test case that we will be using to demonstrate a GET call that will output the response body and validate a specific set of fields. The full example will be provided at the end.

 GET Existing User  
   GET      /users/1  
   Output   response body

Firstly, we make the `GET` call to the `/users/1` endpoint, and we expect user 1 to have a specific set of data. Before we go further though, we first `OUTPUT` the response body to see what is returned. As you can see below, the entire response body is outputted.

 JSON for 'response body' is:  
 {  
   "id": 1,  
   "name": "Leanne Graham",  
   "username": "Bret",  
   "email": "Sincere@april.biz",  
   "address": {  
     "street": "Kulas Light",  
     "suite": "Apt. 556",  
     "city": "Gwenborough",  
     "zipcode": "92998-3874",  
     "geo": {  
       "lat": "-37.3159",  
       "lng": "81.1496"  
     }  
   },  
   "phone": "1-770-736-8031 x56442",  
   "website": "hildegard.org",  
   "company": {  
     "name": "Romaguera-Crona",  
     "catchPhrase": "Multi-layered client-server neural-net",  
     "bs": "harness real-time e-markets"  
   }  
 }

Now that we have the response body, we can pick and choose what we want to validate. In our case, we want to verify the following fields.

Verify the returned id is `1`
Verify the name is `Leanne Graham`
Verify the street is `Kulas Light`
Verify the lat is `-37.3159`, we do this so we can demonstrate how to traverse the tree. Notice the pattern yet?

Our final test case will look something like this.

 GET Existing User  
   GET      /users/1  
   Integer  response body id               1  
   String   response body name             Leanne Graham  
   String   response body address street   Kulas Light  
   String   response body address geo lat  -37.3159

Here we remove the Output, as we no longer need it to figure out what fields to validate. We then verify each individual field by validating both its type and its value. In our case, we want to ensure that the id that is being returned is an Integer and has the value of 1. As for the remaining items, we ensure that they are strings, and we traverse down the json tree to validate each individual value. I hope this brief tutorial helped!

For more examples, visit the github page!

RESTinstance - RESTful Basic Authentication

2018-05-11T11:45:00.001-04:00

Tip of the Day

When using the RESTinstance library, it is incredibly easy to do basic authentication login.
Todays example will demonstrate how to login to a RESTful API service without passing in any added headers (if you want an example of that, let me know), but will use the json schema to validate the returned response from your POST call.

Test Example

 *** Test Cases ***  
 POST Login Valid User  
   Expect Response   ${CURDIR}/schemas/valid/basic_auth_schema.json  
   POST  /api/login  body={"email":"ex@g.com","password":"example"}

Usually, you would want to test the status code after your `POST` by using the `Integer` call, but by calling `Expect Response` and using the schema, you can have all of your status code and required response fields all in one!

JSON Schema

 {  
   "body":{  
    "type":"object",  
    "properties":{  
      "token":{  
       "type":"string"  
      }  
    },  
    "required":[  
      "token"  
    ]  
   },  
   "status":{  
    "type":"integer",  
    "example":200,  
    "enum":[  
      200  
    ]  
   }  
 }

When a `POST` call is made, the schema is asserting that the status code should return a 200 response code, and the token should be returned as a string.

And that's all there is to it! Easy right? Good luck!

You can download a fully working example and more!
Download on github.

RESTinstance - How to do Schema Validation

2018-05-07T15:49:00.002-04:00

Tip of the day

When you are testing schemas using the RESTinstance library, you need to ensure that the `Expect Response` call is always made before your actual REST verb call. Generally, you will want to make your `Expect Response` call in the Test Setup since most of your test cases will likely have the same schema response.

If you tried using the `Expect Response` call after a REST verb, the keyword will always pass since there is no response for it to actually verify. This is because the `Expect Response` call is only checked during the REST verb call, so if you call it after a response has been made, then nothing will occur!! Don't fall into the trap of keywords passing without first verifying it with a known good and bad state! Hope this helps!

Example Test Case Usage

POST Sign Up    Expect Response     ${CURDIR}/schemas/valid/signup_schema.json
    POST        /signup             body={"user": "Bob", "pw": "badpw"}

Example Schema

{
   "status":{
      "type":"integer",
      "enum":[
         200,
         201,
         204
      ]
   },
   "body":{
      "type":"object",
      "properties":{
         "token":{
            "type":"string"
         },
         "email":{
            "type":"string"
         },
         "id":{
            "type":"string"
         }
      },
      "required":[
         "id",
         "token"
      ]
   }
}

RESTinstance - How to disable SSL Verification

2018-04-15T15:30:00.001-04:00

When I started to use the RESTinstance library, it was super easy to do schema and RESTful API testing. However, my next task was to do some basic authentication API testing for one of our development environments. Initially, when I connected to our basic auth. endpoint, I was getting a domain certification error. SSL certification verification is enabled by default in the RESTinstance library, which is a good thing, but since we didn't have a certificate ready yet, we needed to disable it for the time being.

Luckily, its super easy to disable SSL certificate verification in the RESTinstance library! It's just a simple boolean you pass in when you import the library.

In our example below, we disable verification by adding the boolean `ssl_verify=False` in our import, and to demonstrate Basic Authentication using the RESTinstance library, we also pass in the user credentials to a login endpoint. We then check the response codes for a successful login. The example below will not work with the website listed, it is just there to demonstrate the concept of how it would work with your own endpoint. Good luck!

Example

** Settings ***
Library         REST     https://example.com    ssl_verify=false

*** Test Cases ***
Basic Auth Example
    POST            /user/login    body={ "username": "Batman", "password": "robinpwd1940" }
    Output          response
    Integer         response status                 200

How To Access A Specific Index In A Robot Framework Collection

2018-03-01T19:48:00.000-05:00

*** Test Cases ***

How To Access A Specific Index In A Robot Framework Collection

# Create the collection for consumption

${collection} = Create List A B C D E

# Demonstrate the use of accessing the index with assertions

Should Be Equal As Strings ${collection[0]} A

Should Be Equal As Strings ${collection[1]} B

Should Be Equal As Strings ${collection[2]} C

Should Be Equal As Strings ${collection[3]} D

Should Be Equal As Strings ${collection[4]} E

# View in log.html

Log ${collection[0]}

# View in Console Command

Log To Console ${collection[3]}

Testing JSON Endpoints With Robotframework

2017-01-01T11:14:00.001-05:00

Below is an example robot file that you can use to experiment with endpoint testing. Responses are returned in JSON.

*** Settings ***
Documentation Robot Framework JSON and REST Testing
... Author: JJ The Engineer
... We use a free 3rd party site to demo these tests.
... Credits: jsonplaceholder.typicode.com

Library Collections
Library HttpLibrary.HTTP
Library DateTime
Library String

*** Variables ***
#Breakdown of endpoint below: https://jsonplaceholder.typicode.com/users
${HOST} jsonplaceholder.typicode.com
${SCHEME} https
${ENDPOINT} /users

*** Test Cases ***
Get Users Endpoint Should Be Successful
Create Http Context ${HOST} ${SCHEME}
GET ${ENDPOINT}
Response Status Code Should Equal 200

Validate JSON
${response_body} = Get Response Body
Should Be Valid Json ${response_body}
Log Json ${response_body}

Validate Dictionary
${response_body} = Get Response Body
Log Json ${response_body}
${dictionary} = Evaluate json.loads('''${response_body}''') json
Log Dictionary ${dictionary}

How to evaluate JSON in Robot Framework

2016-12-27T17:41:00.003-05:00

Here is a simple example that will demonstrate how to evaluate JSON in Robot Framework. This can be useful if you are attempting to do some form of API testing that requires you to assert return values.

In our robot file, we will create a JSON variable, and utilize Python's built-in json loader to retrieve the data. Once we get the JSON loaded, we can use the "password" key to verify the expected value. I've added color coding to help show you what parts are matching.

*** Variables ***

${js string}= {

... "random": {

... "passwd_change_date": "2016-12-16T11:26:26",

... "passwd_fail_count": 0,

... "password": "123456789",

... "status": 0,

... "user_name": "test@test.com"

... }

*** Test cases ***

&{data}= Evaluate json.loads($js_string) json
&{data}= Set variable &{data}[random]

Should be equal &{data}[password] 123456789

Source Reference:

How To Use Optional Keyword Arguments in Robot Framework

2016-12-27T00:31:00.002-05:00

The Robot Framework documentation explains how to use optional keywords quite clearly, but I wanted to write up a quick example to display the use of default and optional values.

.robot file

*** Test Cases ***

Example Vegetable List

Fill Grocery List

Fill Grocery List type=Tomato

*** Keywords ***

Fill Grocery List

[Arguments] ${type}=Potato ${category}=Vegetable

Input Text id=type ${type}

Input Text id=category ${category}

Values for Grocery List 1 will be Potato, Vegetable
Values for Grocery List 2 will be Tomato, Vegetable

In Grocery List 2, we only changed the type from Potato to Tomato. Note how we don't call category at all since we are not changing it. If we wanted to make a change to category, we can add category=Fruit when we make the Fill Grocery List call.

"Free keyword arguments support variables similarly as named arguments. In practice that means that variables can be used both in names and values, but the escape sign must always be visible literally. For example, both foo=${bar} and ${foo}=${bar} are valid, as long as the variables that are used exist. An extra limitation is that free keyword argument names must always be strings. Support for variables in names is a new feature in Robot Framework 2.8.6, prior to that possible variables were left un-resolved."

Reference Material:

How to setup Jenkins and Robot Framework with Git

2016-12-26T12:49:00.004-05:00

This is a quick and dirty guide to setting up Robot Framework in Jenkins. Since we store all of our robot test cases in git, we will utilize Source Control to ensure we are running our latest tests. This guide also assumes you have a remote selenium grid setup to run tests against. For more detailed steps on how some of the steps are done, please review the reference links. And as always, please ensure you have a backup of Jenkins or whatever you are modifying before you start!

Required Installations on Jenkins

- git

- python 2.7+

- robotframework

Required Plugins for Jenkins

- Jenkins GIT plugin

- Robot Framework plugin

SSH onto the Jenkins machine itself.

1) Verify python is installed (check using which python)

- If not installed, please look for a more detailed python installation guide.

- Detailed Python Install Guide 1

- Detailed Python Install Guide 2

- Important Note, you can stick with the default version of python, but I opted for version 2.7 and since Jenkins is installed on a CentOS box, version 2.6 should automatically be installed by default. I decided to install a separate 2.7 python package to prevent deprecated command warnings.

Example warnings from 2.6 that are not present in 2.7

/usr/lib/python2.6/site-packages/selenium/webdriver/remote/webdriver.py:548: DeprecationWarning: use driver.switch_to.alert instead

  warnings.warn("use driver.switch_to.alert instead", DeprecationWarning)

     /usr/lib/python2.6/site-packages/selenium/webdriver/remote/webdriver.py:542: DeprecationWarning: use driver.switch_to.default_content instead
  warnings.warn("use driver.switch_to.default_content instead", DeprecationWarning)
     /usr/lib/python2.6/site-packages/selenium/webdriver/remote/webdriver.py:536: DeprecationWarning: use driver.switch_to.frame instead
  warnings.warn("use driver.switch_to.frame instead", DeprecationWarning)

Below is a simple guide for version 2.7:

Retrieve and untar python package

wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tar.xz

xz -d Python-2.7.10.tar.xz

tar -xvf Python-2.7.10.tar

Build and Install package

cd Python-2.7.10

./configure --prefix=/usr/local

make && make altinstall

Install pip

wget https://bootstrap.pypa.io/get-pip.py

python2.7 get-pip.py

Install Virtualenv

pip2.7 install virtualenv

If you are having pathing issues, you can always try loading the source of 2.7

sudo /usr/local/bin/pip install virtualenv

2) Verify git is installed (if not installed, a simple yum install git should do the trick)

3) Install robotframework and selenium libraries
pip2.7 install robotframework
pip2.7 install robotframework-selenium2library

4) Setup an SSH key pairing (no passphrase) between Jenkins and bitbucket (or wherever your code is hosted)

- Good reference material https://help.github.com/articles/generating-ssh-keys/

- If you are having trouble after setting up the pairing, make sure to run the command that jenkins gives out on the box itself. There is a first time setup message that prompts the user whether or not to trust the source.

5) Create a new jenkins job (Check the jenkins robot plugin guide)

Example:

a) Build free-style > Add build step > Execute Shell

pybot --variable browser:firefox --output my_robot_results my_test_suite

b) Add Post-build Actions > Publish Robot Framework Test Results

Directory of Robot Output > my_robot_results

c) Select Advanced ... Options if you want to save screen shots in your reports

Output xml name > output.xml

Report html name > report.html

Log html name > log.html

Other files to copy > *.png

- The plugin guide mentions that you should have all results return as Exit 0 to let the plugin decide on whether it is a success/failure, but I opted to just have a Build Failure whenever there is a failed test.

- Post-Build Actions > Publish Robot Framework Test Results

- Disable thresholds, you should only be writing critical tests

5a) PROTIP: If you want to run multiple browsers with the same jenkins job, instead of using a free-style project, use a multi-configuration project and define your matrix variables for the browser.

Configuration Matrix > User-defined Axis

Name > BROWSER

Values > chrome firefox safari

Once you define your matrix, calling robot only requires a small change.

pybot --outputdir my_robot_results --variable BROWSER:$BROWSER my_test_suite

6) You should now be able to run your tests! Results will be displayed under "Robot Results" in the vertical menu options.

Sample Screenshots

Good luck and have fun with Robot Framework and Jenkins!

P.S. If you are running on CentOS and pybot is still running python 2.6, you can force robot to use version 2.7.

vim /usr/bin/pybot

Change the first line from

#!/usr/bin/python to #!/usr/local/bin/python2.7

Selenium Grid 3.0 Setup - Migrating from Version 2 to 3

2016-12-18T21:31:00.000-05:00

If you are migrating from Selenium Grid 2 to 3, there are only a few minor changes that you will need to make in the batch and json config files. The biggest issue I ran into when migrating was getting the node to start without closing immediately. In Selenium 3, you need to make sure that your -Dwebdriver call is before the -jar parameter.

Batch file to start Node in Selenium 3.0

START "local-node" java -Dwebdriver.chrome.driver=chromedriver.exe -jar selenium-server-standalone-3.0.1.jar -role node -nodeConfig nodeConfig.json

Batch file to start Node in Selenium 2.0

START "local-node" java -jar selenium-server-standalone-3.0.1.jar -role node -nodeConfig nodeConfig.json -port 4451 -browser "browserName=chrome,maxInstances=4" -Dwebdriver.chrome.driver=chromedriver.exe

Take note of how the -Dwebdriver call is now before -jar, and -browser is removed. You can define the browser options in the nodeConfig json.

Reference Links:

Example Version 3 Hub JSON
https://github.com/SeleniumHQ/selenium/blob/master/java/server/src/org/openqa/grid/common/defaults/DefaultHub.json

Example Version 3 Node JSON
https://github.com/SeleniumHQ/selenium/blob/master/java/server/src/org/openqa/grid/common/defaults/DefaultNodeWebDriver.json

There isn't a full doc on version 3 - but this link shows some of the differences as well. https://github.com/SeleniumHQ/selenium/wiki/Grid2

Hopefully this provides some guidance if you are having trouble getting the grid to run.

Thanks,

- JJ The Engineer

Tutorial: How to setup Zeusminer on Ubuntu

2014-08-02T00:10:00.001-04:00

Here is a tutorial for those who want to run the Zeusminer on Ubuntu.

Backstory:
I was having a very tough time finding a tutorial on how to setup the Blizzard Zeusminer. After fiddling with the default cgminer that you can download from the main Zeus support site and ultimately failing, I opted to try something else. One of the errors that I couldn't overcome was the dreaded, "all devices disabled, cannot mine!" After several hours of research, I finally got my brand new Zeusminer to work! The setup is fairly simple and should take only ~10 minutes (assuming you've already downloaded everything).

Software that I used:
- OS: Ubuntu 14.04 LTS x64 version(wiki - download latest desktop version)
- Miner: BFGMiner 4.3.1 - Precompiled Ubuntu x64 version by worldly download
- BFGMiner Resource Topic - The fork is currently frozen, but in the event it melts, refer to this guide for reference.

Chips-Count (--zeus-cc)

Blizzard: 6
Cyclone: 96
Hurricane X2: 48 (2*24)
Hurricane X3: 64 (2*32)
Thunder X2: 96 (4*24)
Thunder X3: 128 (4*32)

Step by Step Guide:

This will assume that you already have Ubuntu 14.04 LTS installed. I installed Ubuntu onto my 16GB flash drive instead of using a regular hard disk or an SSD.

You will need to download the BFGMiner 4.3.1, if this is no longer working, please get the latest link from the BFGMiner Resource Topic.
Once you have it downloaded, drag and drop the file from your Downloads directory into your Documents directory.
Now, open up a terminal and navigate to the Documents directory
You need to enable BFGMiner, so this requires you to make the program an executable. To do that, enter the following command: chmod +x bfgminer
At this point, you should already have your shiny new Zeus miner plugged in via USB and all juiced up from the AC adapter. (It doesn't matter when you decide to plugin the USB or AC adapter, this is just a friendly reminder in case you forgot!)
Now you just need to execute the newly enabled BFGMiner with the Zeusminer configurations and your pool information.

Blizzard Zeusminer Example: (Make sure to replace hostname, port, username and password with your own information)

./bfgminer --scrypt -o stratum+tcp://hostname.jj:1234 -u user.worker -p password --zeus-cc 6 --zeus-clk 340 -S zeus:/dev/ttyUSB0

7. Enjoy mining your scrypt coin! Good luck :)

If you found this tutorial helpful and would like to leave a tip, thanks :)
BTC - 16fDkF46r85s4ej3Ecf9a5wNqbfXuc41a
LTC - LTZHjty9FtzCLzupBkevNF51D3S8XjN2Fi
Doge - DT8gD24ZirccSrWigAJEXWkBfk9C9ciuej

Pictures of Zeusminer Blizzard:

Zeusminer Blizzard

Zeusminer Blizzard, USB cord and Power Adapter

How to wire your house with ethernet

2014-05-07T19:03:00.002-04:00

Reason/Need

This post is made specifically to document the networking portions of my house wiring that I recently had to do (5/3/14). I basically wanted to install Ethernet wall outlets in all of the bedrooms, the living room and \ the basement. By providing an Ethernet outlet in each room, I no longer needed to rely exclusively on WiFi for my Internet connections. A hard wire also provides a more reliable network connection which is something that was necessary since WiFi was in the basement and my desktop was on the first floor.

The basis of what I had to do was cut holes into my walls and then use the open basement ceilings to do the wiring. I then connected all of my outlets to a main switch which connected to my WiFi router (so that they can all be in the same LAN) and then to the cable modem. It is important to use the router for DHCP so your LAN can share files across different devices, unless of course you don't want to do that...

Required Items

For this project I opted for 2 Ethernet jacks per outlet, Cat6 cables for future proofing and super fast LAN file transfer speeds. There are 5 rooms that needed to have outlets installed, but the basement required 2 outlets. I also had two spools to make wiring easier through the house easier. It adds to the cost, but it saves you a lot of work if you are doing two Ethernet jacks per outlet.

1 Green Ethernet Spool of Cat6 $128
1 Orange Ethernet Spool of Cat6 $128
6 Cat6 RJ-45 Toolless Keystone - Green $5.38 x 6 = $33
6 Cat6 RJ-45 Toolless Keystone - Orange $5.24 x 6 = $32
6 1-Gang Low Voltage Mounting Bracket $7.29 x 6 = $44
6 Wall Plates for Keystones, 2 Hole $6.45 x 6 = $39
1 RJ-45 Modular Plug Tester $10
1 Bag of 100pc Cat6 Plug Solid W/Insert 50U $12
1 8P8C RJ-45 Network Cable Crimper $10
1 16 port Gigabit Switch $70
1 Wireless Gigabit Router $137

Estimated Cost: ~$643

Picture Walkthrough

Here we have a hole that we cut in the wall with a 1 Gang Low Volt Bracket installed. These are pretty simple to install, just make sure the back piece is against the top and bottom of the wall. We already snaked the Ethernet cord down from the ceiling.

Here is a green keystone that I have already wired up. Basically, you will just need to strip the outer layer, snake the 4 pairs through the small opening, place them in according to pattern B and then close the top. I recommend using a wrench of some form to close the top and bottom. I had a lot of trouble doing this which just my fingers. Please note, you MUST follow the B pattern on the keystone. As this will be very important when you need to crimp the other side of the cable to plug into the switch. If you need help with crimping the other end of the keystone cable, I have written a tutorial which you can find in this link.

Closer view of the keystones #1.

Closer view of the keystones #2.

Closer view of the keystones #3.

Once you have all of the keystones setup, place them into the wall plate and mount it onto the low volt bracket.

Wall Plate with Keystones all setup.

Now you want to test to see if everything is working properly. In order to test, just plug in a known working cables into the outlet and into the cable tester as seen above. Then on the opposite end, plug in the other half of the cable tester into the end of keystone wire that you had just crimped. If the numbers on the second cable tester goes from 1-8 sequentially, then your wire is working properly!

Here is a picture of the ceiling area with all of the Ethernet wiring.

More wiring, but bunched up and hidden away along the top of the basement ceiling.

The ends of each keystone fully tested and plugged into my switch.

End Notes

This was my first experience doing a home networking project of this scale, but I think it worked out pretty well. I now live in a place that has Ethernet outlets across all rooms, so if wireless ever becomes an issue, I can always add in a wireless router on the first floor. I can also get internet reliably using Ethernet for my desktop which was one of my main requirements. File sharing and having media stream across different rooms will now be much faster and more reliable. Overall, this project made the Internet more accessible for devices that did not have WiFi and cost me under $700 in equipment costs to fully network my home. I would like to thank those who have helped me with this project because 4 people doing wiring is much easier than doing it all yourself. I hope this project document will help others in the future who are also looking to install Ethernet wall plates in their homes.

If you have any questions about anything networking related in this post, please feel free to ask. :)

Special thanks to Adam, Eric and Erik!

How to Crimp Cat6 cable

2014-05-06T20:37:00.001-04:00

Recently, I have had a need to crimp my own cables for wiring up a house to install ethernet outlets across a house. Since all the wires require a different length, I opted to order two giant spools of Cat6 for all my wiring needs. So you may be wondering why I opted for Cat6 and not Cat5e. Well the answer is simple, future proofing. Since Cat6 can support 1Gbps, and Cat5e can only 100Mbps, it made sense to spend the money now than have to upgrade the cables later. With Cat6, local LAN transfer speeds will be super fast! A tutorial on how to setup ethernet outlets will be in another article. For now we will focus on how to crimp cables.

Requirements

In order to crimp a Cat6 cable, you will need the following items:

1 Desired length of 23AWG Cat6 500MHz UTP Solid Riser Rated Ethernet Cable
1 RJ45 Modular Plug Tester
1 8P8C RJ-45 Network Cable Crimper
1 or 2 depending on wire Cat6 Plug Solid W/Insert 50U

The items listed are the exact tools that I have ordered and used to crimp Cat6 cables in this tutorial. Since Cat6 uses RJ-45, this will work with other Ethernet cords as well such as Cat5 and Cat5e.

Instructions

RJ-45 Connector(top) with Insert Holder(bottom).
Here is the Cat6 Plug for the ethernet end. You will notice that there are two pieces which is not typical when ordering RJ-45 connectors, but the second small piece will make crimping much easier. The smaller piece called the insert holder will help you organize your wires in place when inserting it into the rest of the RJ-45 connector.

Cat6 Ethernet Cable with unfinished end

The first thing you want to do is to strip about an inch of the outer coating to make organizing and wiring easier.

Once you strip the outer coating, you should get something similar to this in Cat6. There will be a clear plastic piece inside that separates the 4 pairs and a string. You want to cut the clear plastic piece and string out before you begin organizing your wires.

Once you cut out the clear plastic piece and string, just untangle the wires so you can use the insert holder in the next step. Also note there there is still a little bit of clear plastic at the end, but that is okay!

Now you want to insert the wires into the insert holder with the smooth back on the bottom, and the side with the ridges and metal on top. Organize the wires from left to right in the order shown above.
Half Orange, Orange, Half Green, Blue, Half Blue, Green, Half Brown, Brown.

Make sure you push the wires through the insert holder with about a cm between the insert holder and the outer coating as seen above. From there you will want to make an even cut with your crimper as seen above. Make sure the crimper blades are not super close to the insert holder, give it a tiny bit of space.

Nice even cut with the crimper. You will notice that we left a little bit of space at the end of the connector, and this is intentional.

Now you want to push the wire into the RJ-45 connector. Make sure that the insert holder sits evenly inside and you can see the ends of the wires in front of the connector.

Once you have verified that you can see the ends of the wires in front of the RJ-45 connector. You now want to use your crimper to actually crimp the cable as shown above. Make sure the RJ-45 connector is in all the way and squeeze the crimper to finish the connection between the wire and RJ-45 connector.

The final step is to test your cable! If they match from 1-8, then you have successfully crimped that cable! Congrats!