Corey Goldberg

Python - Using Chrome Extensions With Selenium WebDriver

2018-09-07T12:07:00.001-04:00

When you launch a Chrome browser from Selenium, a fresh temporary profile is created for the browser session. This means that by default, Chrome extensions are not loaded. To use an extension during a Selenium test, you must install the extension each time you launch a new browser.

Example 1: Installing a packed extension

A packed extension comes in the form of a single .crx file.

You can install a packed extension like this:

Example 2: Installing an unpacked extension

An unpacked extension is a directory containing extension code.

You can install an unpacked extension like this:

examples tested with: chromium 68, chromedriver 2.41, selenium 3.14

LG G6 - Quick Charge 3.0 Not Working?

2017-07-06T14:36:00.000-04:00

I finally got my G6 to charge properly with Quick Charge 3.0! Here is what I learned...

The following conditions must be met, or else the G6 steps down power during charging and you will not get a proper QC 3.0 charge:

battery must be below 80% capacity
screen must be turned off
screen saver mode must be disabled

The LG G6 has a Snapdragon 821 SoC that supports Qualcomm's Quick Charge 3.0 technology for rapid charging. However, I haven't been getting very fast charge times on my G6. I tried the stock charger/cable and even several QC-compatible 3rd party accessories. While the G6 showed a "Fast Charging" notification, it didn't seem very fast at all. It also seemed to charge faster over wireless (Qi) than with a charger and cable attached!

So I bought a QC-compatible USB multimeter to test the voltage and current the G6 was drawing during a charge. Just as I suspected, I was *not* getting a Quick Charge at all. The adapter that comes with the G6 is supposed to be able to charge at 9V/1.8A, but I couldn't see it draw anything beyond a 5V/0.5A. After much frustration and troubleshooting, I realized I had my G6 configured to run Screen Saver mode during charging. After disabling the Screen Saver, I finally saw it charge at the full 9V/1.8A!

Also note:

when the "Fast Charging" notification is displayed, it just means a QC compatible charger/cable was detected, not that it's actually charging at QC 3.0 speed.
Screen Saver setting is located at: Settings > Display > Screen saver

Batch Convert Images from PNG to JPEG

2017-02-02T20:02:00.000-05:00

This post briefly shows how to recursively scan a directory tree for PNG images and convert them to JPEG format. To achieve this, we use the `find` shell command and ImageMagick's `convert` utility. We use GNU Parallel to speed up processing time by executing conversions in parallel. This should make efficient use of all CPU cores.

First, install ImageMagick and GNU Parallel. For example, on Debian/Ubuntu you would run:

$ sudo apt-get install imagemagick
$ sudo apt-get install parallel

Once these are installed, `cd` to the root of the directory tree containing your images, and run:

$ find . -iname "*.png" | parallel convert -quality 95% {} {.}.jpg

This shell pipeline will:

* recursively search under the current directory
* match files that have the [case-insensitive] `.png` extension
* convert each PNG image to JPEG format at 95% quality
* save the new image with the file extension changed to `.jpg`

Once converted, you can delete the original PNG images with:

$ find . -iname "*.png" | parallel rm {}

What The Heck Happened To Conky? (I'm rolling back to 1.9)

2016-03-09T12:48:00.001-05:00

Conky is a stalwart on my desktops. All my system info is a glance away in that great little monitoring tool.

However, Conky 1.10 is extremely buggy and has made incompatible changes to it's config syntax since the 1.9 release.

The changes from conky 1.9->1.10 made for an incompatible disaster and conky is now totally borked in the current Ubuntu 16.04 repos. Bugs have been reported... but, while maintainers and devs figure out issues, I need my old conky back!

So I just reverted to the old `conky-std` 1.9.0 in Ubuntu 16.04, and I'm back in business for now.

Here is how I did it:

First, let's see which conky version is in installed on my 16.04 (Xenial) machine:

$ conky -v | head -n 1 | cut -d" " -f 2
1.10.1

so, I removed this borked conky and purged it's configurations and leftover dependencies:

$ sudo apt-get remove --purge conky-std && sudo apt-get autoremove

I wanted conky version 1.9, which is not in the Ubuntu Xenial repos. So I snagged the package that shipped with Trusty:

$ wget http://security.ubuntu.com/ubuntu/pool/universe/c/conky/conky-std_1.9.0-4_amd64.deb

once I had the .deb package downloaded, I installed it with `gdebi` rather `dpkg` so it would also install the necessary dependencies:

$ sudo gdebi conky-std_1.9.0-4_amd64.deb

we should now be back in business. Let's check the version that is installed:

$ conky -v | head -n 1 | cut -d" " -f 2
1.9.0

score!

One final task is pin the package at the 1.9.0 version so future package updates don't revert us back up to the bad version:

$ sudo apt-mark hold conky-std

done!

I'm back running conky 1.9 like a boss for now. I hope the upstream situation gets sorted soon.

TLDR:

$ sudo apt-get remove --purge conky-std && sudo apt-get autoremove
$ wget http://security.ubuntu.com/ubuntu/pool/universe/c/conky/conky-std_1.9.0-4_amd64.deb
$ sudo gdebi conky-std_1.9.0-4_amd64.deb
$ sudo apt-mark hold conky-std

happy hacking.

Ubuntu - Changing the bootsplash screen

2015-11-29T16:08:00.000-05:00

Plymouth is the default bootsplash app used in Ubuntu... It displays the Ubuntu logo while booting.

For as long as I can remember, every time I install the proprietary NVidia display driver, my bootsplash gets borked. It just displays a black screen, then a few flickers of the Ubuntu logo or NVidia logo, then the desktop is presented.

It seems that simply resetting the default plymouth theme fixes this issue:

$ sudo update-alternatives --config default.plymouth

apply changes:

$ sudo update-initramfs -u

Here is how to switch the bootsplash to [my favorite] the solar theme:

$ sudo apt-get install plymouth-theme-solar
$ sudo update-alternatives --config default.plymouth
$ sudo update-initramfs -u

then reboot!

more info:
https://wiki.ubuntu.com/Plymouth

Linux - Simulating Degraded Network Conditions

2015-04-27T11:55:00.000-04:00

When testing an application or service, it can be very useful to simulate degraded network conditions. This allows you to see how they might perform for real users. Testing on a controlled LAN is not always realistic, since the LAN has much different network properties than a real user would experience over a WAN.

I will give examples using 2 tools that alter a network interface's properties. The tools are: NetEm and Wondershaper.

NetEm is an enhancement of the Linux traffic control facilities that allows you to add delay, packet loss, duplication, corruption, reordering, and more to outgoing packets from a specified network interface. NetEm is controlled by the command line tool tc, which is part of the iproute2 package and included in most Linux distros.

Wondershaper is a traffic shaping script that allows you to throttle network transfers on a specified network interface. This is useful for testing latency when bandwidth is limited.

Examples:

tc/NetEm:
add fixed 250ms delay to all outgoing packets on Ethernet interface eth1:
  $ sudo tc qdisc add dev eth1 root netem delay 250ms
turn it off:
  $ sudo tc qdisc del dev eth1 root netem

Wondershaper:
limit bandwidth of eth1 interface to 256kbps upload and 128kbps download:
  $ sudo wondershaper eth1 256 128
turn it off:
  $ sudo wondershaper clear eth1

rsync for file sync and backup - storing my peronal media

2014-08-31T16:19:00.000-04:00

You do backup all of your important files, right?

TLDR: Dropbox + NAS + Local Storage + rsync = my backup strategy.

I have a lot of data that is important to me. Mostly: documents, code, images, music, and videos. I currently have about 1.2TB stored. This is an overview of how I store and backup my data.

About rsync:

rsync is a great file synchronization and file transfer program. Since being announced in 1996, it has become a standard Linux utility, included in all popular Linux distributions (and other Unix-like systems).

I have a Dropbox with an 11GB quota. This suffices for storing my documents, code, and images. It nicely syncs them to to all my computers. I can easily access this data from outside my LAN on any device I own.

Then I have a NAS as my main storage within my LAN. It is a 2-bay enclosure, with 2 2TB hard drives inside that are in a RAID configuration. I can easily access all of my media from any computer or device on my home network. I also have a secondary NAS attached to my network, purely for backup/disaster situations.

To complete the storage picture... on my main workstation, I have a 2TB hard disk mounted as a secondary data drive.

Storage Overview:

Dropbox
2 NAS servers mounted as drives on my main workstation (using SMB)
Main workstation with 2TB Hard disk mounted internally
Gigabit Ethernet LAN

So, that's the given hardware setup. I use a shell script to actually run my backup. It is initiated from the main workstation (scheduled from cron).

The script follows this workflow:

local Dropbox gets rsync'ed to my primary NAS
primary NAS gets rsync'ed to my local workstation's data drive
primary NAS gets rsync'ed to my backup NAS

I have ~20k files (~1.2TB) in my archive. The first time running the backup job was slow (several hours), but subsequent backups are extremely fast. This is due to the rsync algorithm, delta encoding, and compression. If not many files changed since my last backup/sync, differential backups take only a few seconds or minutes.

Besides not having a offsite copy for disaster recovery, I like this system, and it makes me sleep well knowing my data is safe and recoverable.

Any flaws?

Python - Fixing My Photo Library Dates (Exif Metadata)

2014-01-11T11:02:00.000-05:00

I have a large image library of photos I've taken or downloaded over the years. They are from various cameras and sources, many with missing or incomplete Exif metadata.

This is problematic because some image viewing programs and galleries use metadata to sort images into timelines. For example, when I view my library in Dropbox Photos timeline, images with missing Exif date tags are not displayed.

To remedy this, I wrote a Python script to fix the dates in my photo library. It uses gexiv2, which is a wrapper around the Exiv2 photo metadata library.

The scipt will:

recursively scan a directory tree for jpg and png files
get each file's creation time
convert it to a timestamp string
set Exif.Image.DateTime tag to timestamp
set Exif.Photo.DateTimeDigitized tag to timestamp
set Exif.Photo.DateTimeOriginal tag to timestamp
save file with modified metadata
set file access and modified times to file creation time

* Note: it does modifications in-place.

The Code:

Gource Visualization of Ubuntu Touch Core Apps Development

2013-11-17T14:12:00.000-05:00

TLDR: I made a cool version control visualization of all the Ubuntu Touch Core Apps.

The video: https://www.youtube.com/watch?v=nAmKAgRS0tw

* Warning: abrasive techno music
* To be watched in HD, preferably at maximum volume

Making Gource visualizations of complex software projects is awesome. I love seeing a VCS commit log come to life as blooming trees and swarming workers. Normally, I do a visualization video of a single repository. But in this case, I used a bash script to create a visualization of multiple source code repositories. I wanted to see the progress of the entire stack of Ubuntu Touch Core Apps (17 projects). Ubuntu Touch Core Apps is an umbrella project for all [17] of the core apps that are available in Ubuntu on mobile devices

The Ubuntu Touch Core Apps:

Dropping Letters
Evernote Online Accounts plugin
QtDeclarative bindings for the Grilo media scanner
Stock Ticker App
Sudoku App
Ubuntu Calculator App
Ubuntu Calendar App
Ubuntu Clock App
Ubuntu Document Viewer App
Ubuntu E-mail App
Ubuntu Facebook App
Ubuntu File Manager App
Ubuntu Music App
Ubuntu Phone Commons
Ubuntu RSS Feed Reader App
Ubuntu Terminal App
Ubuntu Weather App

Making the visualization:

Assuming you have a bunch of source code repositories already branched/cloned locally, here is a general version of the script to generate visualization videos of multiple projects/repositories: https://gist.github.com/cgoldberg/7488521

The script I used to create the Ubuntu Touch Core Apps video: https://gist.github.com/cgoldberg/7516510

deadsnakes - Using Old Versions of Python on Ubuntu

2013-10-22T10:38:00.000-04:00

How do you install an older version of Python on Ubuntu without building it yourself?

The Python packages in the official Ubuntu archives generally don't go back all that far, but people might still need to develop and test against these old Python interpreters. Felix Krull maintains a PPA (package archive) of older Python versions that are easy to install on Ubuntu.

see: https://launchpad.net/~fkrull/+archive/deadsnakes

Currently supported Python releases: 2.4, 2.5, 2.6, 2.7, 3.1, 3.2, 3.3

Instructions:

Add the deadsnakes repository:

$ sudo add-apt-repository ppa:fkrull/deadsnakes

Run Update:

$ sudo apt-get update

Install an older version of Python:

$ sudo apt-get install python2.6 python2.6-dev

Generating Audio Spectrograms in Python

2013-06-22T15:44:00.000-04:00

A spectrogram is a visual representation of the spectrum of frequencies in a sound sample.

more info: wikipedia spectrogram

Spectrogram code in Python, using Matplotlib:
(source on GitHub)

"""Generate a Spectrogram image for a given WAV audio sample.

A spectrogram, or sonogram, is a visual representation of the spectrum
of frequencies in a sound.  Horizontal axis represents time, Vertical axis
represents frequency, and color represents amplitude.
"""


import os
import wave

import pylab


def graph_spectrogram(wav_file):
    sound_info, frame_rate = get_wav_info(wav_file)
    pylab.figure(num=None, figsize=(19, 12))
    pylab.subplot(111)
    pylab.title('spectrogram of %r' % wav_file)
    pylab.specgram(sound_info, Fs=frame_rate)
    pylab.savefig('spectrogram.png')


def get_wav_info(wav_file):
    wav = wave.open(wav_file, 'r')
    frames = wav.readframes(-1)
    sound_info = pylab.fromstring(frames, 'Int16')
    frame_rate = wav.getframerate()
    wav.close()
    return sound_info, frame_rate


if __name__ == '__main__':
    wav_file = 'sample.wav'
    graph_spectrogram(wav_file)

Spectrogram code in Python, using timeside:
(source on GitHub)

"""Generate a Spectrogram image for a given audio sample.

Compatible with several audio formats: wav, flac, mp3, etc.
Requires: https://code.google.com/p/timeside/

A spectrogram, or sonogram, is a visual representation of the spectrum
of frequencies in a sound.  Horizontal axis represents time, Vertical axis
represents frequency, and color represents amplitude.
"""


import timeside


audio_file = 'sample.wav'

decoder = timeside.decoder.FileDecoder(audio_file)
grapher = timeside.grapher.Spectrogram(width=1920, height=1080)
(decoder | grapher).run()
grapher.render('spectrogram.png')

happy audio hacking.

Python - concurrencytest: Running Concurrent Tests

2013-06-10T09:27:00.000-04:00

Add parallel testing to your unit test framework.

In my previous post, I described running concurrent tests using nose as a loader and runner.

On a similar note, let's look at building concurrency into your own test framework built on Python's unittest.

Have a look at this module: concurrencytest

(Thanks to bits and concepts taken from testtools and bzrlib)

An Example:

Say you have a 'TestSuite' of tests loaded. You could run them with the standard 'TextTestRunner' like this:

runner = unittest.TextTestRunner()
runner.run(suite)

That would run the tests in your suite sequentially in a single process.

By adding the concurrencytest module, you can use a 'ConcurrentTestSuite' instead, by adding:

from concurrencytest import ConcurrentTestSuite, fork_for_tests

concurrent_suite = ConcurrentTestSuite(suite, fork_for_tests(4))
runner.run(concurrent_suite)

That would run the same tests split across 4 processes (workers).

Note: this relies on 'os.fork()' which only works on Unix systems.

There's no way to understand this better than looking at some contrived examples!

This first example is totally unrealistic, but shows off concurrency perfectly. The test cases it loads each sleep for 0.5 seconds and then exit.

The Code:

Output:

Loaded 50 test cases...

Run tests sequentially:
..................................................
----------------------------------------------------------------------
Ran 50 tests in 25.031s

OK

Run same tests across 50 processes:
..................................................
----------------------------------------------------------------------
Ran 50 tests in 0.525s

OK

nice!

Now another example that shows concurrency with CPU-bound test cases. The test cases it loads each calculate fibonacci of 31 (recursively!) and then exit. We can see how it performs on my 8-core machine (Core2 i7 quad, hyperthreaded).

The Code:

Output:

Loaded 50 test cases...

Run tests sequentially:
..................................................
----------------------------------------------------------------------
Ran 50 tests in 21.941s

OK

Run same tests with 2 processes:
..................................................
----------------------------------------------------------------------
Ran 50 tests in 11.081s

OK

Run same tests with 4 processes:
..................................................
----------------------------------------------------------------------
Ran 50 tests in 5.862s

OK

Run same tests with 8 processes:
..................................................
----------------------------------------------------------------------
Ran 50 tests in 4.743s

OK

happy hacking.

Python - Nose: Running Concurrent Tests

2013-06-09T19:17:00.000-04:00

TLDR:
To enable multiprocessing with N workers,
run nose with:

$ nosetests --processes=N

When writing tests in Python, I start with TestCase's derived from unittest.TestCase, and standard test discovery. When I need more complex test discovery/loading or output reports, I often use nose and its assortment of plugins as my test loader/runner.

One nice feature of nose is the multiprocess plugin. It allows you to run your tests suites concurrently rather than sequentially, spread across a number of worker processes. Running tests in parallel like this can potentially give you a large speedup in your test run times.

from the nose multiprocess docs:

"You can parallelize a test run across a configurable number of worker processes. While this can speed up CPU-bound test runs, it is mainly useful for IO-bound tests that spend most of their time waiting for data to arrive from someplace else and can benefit from parallelization."

Normally, you run tests from nose with:

$ nosetests

To run the same tests split across 4 processes (workers), you would just do:

$ nosetests --processes=4

Assuming your tests are properly isolated, everything should run normally, and you can benefit from a speedup on a multiprocessor machine.

However, Beware.

"Not all test suites will benefit from, or even operate correctly using, this plugin. For example, CPU-bound tests will run more slowly if you don't have multiple processors."

"But the biggest issue you will face is probably concurrency. Unless you have kept your tests as religiously pure unit tests, with no side-effects, no ordering issues, and no external dependencies, chances are you will experience odd, intermittent and unexplainable failures and errors when using this plugin. This doesn't necessarily mean the plugin is broken; it may mean that your test suite is not safe for concurrency."

Squeezelite - Headless Squeezebox Emulator

2013-04-01T10:19:00.001-04:00

Use Squeezebox, without buying a Squeezebox...

Recently, Logitech discontinued most Squeezebox streaming music players. However, the media server is Open Source, so it looks like some form of Logitech Media Server (LMS) will live on, no matter what Logitech eventually does with it.

I've been a user of Squeezebox network music player since it was released by SlimDevices (SliMP3/SlimServer), and throughout the transfer to Logitech. I've owned 3 Squeezebox models over the years... currently enjoying the Squeezebox Touch, with music streamed from Logitech Media Server.

It works flawlessly for streaming my own music collection (FLAC/MP3/etc), and streaming radio (Pandora/Slacker/Sirius/etc), to my HiFi. I use the digital (S/PDIF) outputs, and sometimes the DAC/analog (RCA) outputs.

Now... with the release of Squeezelite, you can build your own Squeezebox, or use an existing computer/laptop with digital output as a Squeezebox.

Squeezelite is a cross-platform, headless, LMS client that supports playback synchronization, gapless playback, direct streaming, and playback at various sampling rates. It runs on Linux using ALSA audio output and other platforms using PortAudio. It is aimed at supporting high quality audio.

I gave Squeezelite 1.0 a try on Ubuntu 12.04, with S/PDIF optical output to my DAC. It worked like a charm!

Squeezelite info:
https://code.google.com/p/squeezelite/

Squeezelite download (precompiled binaries for x86/amd64/arm):
https://code.google.com/p/squeezelite/downloads/list

Enjoy the music.

Python - Re-tag FLAC Audio Files (Update Metadata)

2013-03-28T18:35:00.000-04:00

I had a bunch of FLAC (.flac) audio files together in a directory. They are from various sources and their metadata (tags) were somewhat incomplete or incorrect.

I managed to manually get all of the files standardized in "%Artist% - %Title%.flac" file name format. However, What I really wanted was to clear their metadata and just save "Artist" and "Title" tags, pulled from file names.

I looked at a few audio tagging tools in the Ubuntu repos, and came up short finding something simple that covered my needs. (I use Audio Tag Tool for MP3's, but it has no FLAC file support.)

So, I figured the easiest way to get this done was a quick Python script.

I grabbed Mutagen, a Python module to handle audio metadata with FLAC support.

This is essentially the task I was looking to do:

#!/usr/bin/env python

import glob
import os
from mutagen.flac import FLAC

for filename in glob.glob('*.flac'):
    artist, title = os.path.splitext(filename)[0].split(' - ', 1)
    audio = FLAC(filename)
    audio.clear()
    audio['artist'] = artist
    audio['title'] = title
    audio.save()

It iterates over .flac files in the current directory, clearing the metadata and rewriting only the artist/title tags based on each file name.

I created a repository with a slightly more full-featured version, used to re-tag single FLAC files:
https://github.com/cgoldberg/audioscripts/blob/master/flac_retag.py

Python - verify a PNG file and get image dimensions

2013-01-28T17:09:00.000-05:00

useful snippet for getting .png image dimensions without using an external imaging library.

#!/usr/bin/env python

import struct


def get_image_info(data):
    if is_png(data):
        w, h = struct.unpack('>LL', data[16:24])
        width = int(w)
        height = int(h)
    else:
        raise Exception('not a png image')
    return width, height


def is_png(data):
    return (data[:8] == '\211PNG\r\n\032\n'and (data[12:16] == 'IHDR'))


if __name__ == '__main__':
    with open('foo.png', 'rb') as f:
        data = f.read()

    print is_png(data)
    print get_image_info(data)

/headnods:
getimageinfo.py source, Portable_Network_Graphics (Wikipedia)

Python Unit Testing Tutorial (PyMOTW unittest update)

2013-01-23T18:06:00.000-05:00

tl;dr: an update to PyMOTW for `unittest` in Python 3: Python Unit Testing Tutorial.

When I was learning programming in Python, Doug Hellmann's 'PyMOTW' (Python Module Of The Week) blog-series was one of the best resources to learn Python's standard library.

His series later culminated in the book: 'The Python Standard Library By Example'.

The PyMOTW entry on `unittest` was a great introduction to unit testing in Python. Since the PyMOTW version is getting quite outdated, I updated the `unittest` module entry.

This new version includes some edits and updates to the text, and all code and examples have been updated to reflect Python 3.3.

Have a look at my updated Python 3.3 version:
'Python Unit Testing Tutorial'

license: Creative Commons Attribution, Non-commercial, Share-alike 3.0

say no to bugs...

Python - "The Matrix" in your terminal

2013-01-14T09:42:00.001-05:00

Linux console program in Python, that scrolls binary numbers vertically in your terminal. Inspired by the movie: The Matrix

a screenshot:

in action:

the Code:

https://gist.github.com/4530348

Python Testing - PhantomJS with Selenium WebDriver

2013-01-06T16:35:00.000-05:00

PhantomJS is a headless WebKit with JavaScript API. It can be used for headless website testing.

PhantomJS has a lot of different uses. The interesting bit for me is to use PhantomJS as a lighter-weight replacement for a browser when running web acceptance tests. This enables faster testing, without a display or the overhead of full-browser startup/shutdown.

I write my web automation using Selenium WebDriver, in Python.

In future versions of PhantomJS, the GhostDriver component will be included.

GhostDriver is a pure JavaScript implementation of the WebDriver Wire Protocol for PhantomJS. It's a Remote WebDriver that uses PhantomJS as back-end.

So, Ghostdriver is the bridge we need to use Selenium WebDriver with Phantom.JS.

Since it is not available in the current PhantomJS release, you can try it yourself by compiling a special version of PhantomJS:

It wes pretty trvial to setup on Ubuntu (12.04):

$ sudo apt-get install build-essential chrpath git-core libssl-dev libfontconfig1-dev
$ git clone git://github.com/ariya/phantomjs.git
$ cd phantomjs
$ git checkout 1.8
$ ./build.sh
$ git remote add detro https://github.com/detro/phantomjs.git
$ git fetch detro && git checkout -b detro-ghostdriver-dev remotes/detro/ghostdriver-dev
$ ./build.sh

Then grab the `phantomjs` binary it produced (look inside `phantomjs/bin`). This is a self-contained executable, it can be moved to a different directory or another machine. Make sure it is located somewhere on your PATH, or declare it's location when creating your PhantomJS driver like the example below.

for these examples, `phantomjs` binary is located in same directory as test script.

Example: Python Using PhantomJS and Selenium WebDriver.

#!/usr/bin/env python

driver = webdriver.PhantomJS('./phantomjs')
# do webdriver stuff here
driver.quit()

Example: Python Unit Test Using PhantomJS and Selenium WebDriver.

#!/usr/bin/env python

import unittest
from selenium import webdriver


class TestUbuntuHomepage(unittest.TestCase):
    
    def setUp(self):
        self.driver = webdriver.PhantomJS('./phantomjs')
        
    def testTitle(self):
        self.driver.get('http://www.ubuntu.com/')
        self.assertIn('Ubuntu', self.driver.title)
        
    def tearDown(self):
        self.driver.quit()


if __name__ == '__main__':
    unittest.main(verbosity=2)

resources:

What is the Best Way To Learn Selenium?

2012-10-13T13:59:00.001-04:00

(a small rant on asking answerable questions)

At a certain online QA/Testing Forum I regularly visit, the Selenium forum is one of the most active.

I continuously see newbie questions like: "How I do I learn Selenium?", with little or no other context given.

Then, helpful responders chime in with tangentially related answers. That's about as good as you can do, based on the lack of information given in the original post. This happens often and wastes significant brain activity in the responders, while generally giving no value to the OP or forum community.

So first... a clarification:

Selenium WebDriver is a system for automating browser interaction. It is accessed via programming library/API. If you want to use it without touching code, it is not possible (record/replay/export-madness via IDE aside). You can abstract away most of the programming aspects with higher level frameworks, but at that point you are no longer really dealing with Selenium anymore.

Here was my response to a recent forum example:

Question asked:
"Best way to start learning Selenium - I would like to know what is the best practice to start with Selenium for non programmers. Is there any books or ebooks?"

The responses compelled me to chime in with a rant:

To anyone on this thread looking for the "Best way to start learning Selenium":

Think of it this way:

Selenium (WebDriver) provides language bindings and a similar API for several programming languages. It gives you a programming library that can manipulate a browser and web elements/controls.

You can't "learn" a library for a programming language if you don't know the language itself (syntax, idioms, etc).

So the question shouldn't be: "How do I learn Selenium?", with no other information or context given.

Selenium should be used with either: the supported language that you are most comfortable with, or the language of the system under test you are working against.

If you are looking for information, be specific about what you want to learn. General understanding of the components that make up Selenium is great, but really, using the API's from any language is the best way to learn. If you specify a programming language along with your question, at least answers can be directed towards frameworks, code samples, documentation, tutorials, etc, that are *relevant* to you.

Diving into the main Selenium docs can be confusing at first, as it covers things from a general level... mixing in code samples from various languages.

So, my question to you: Which programming language are you going to use Selenium with? If you define that, someone can surely help point you in the right direction.

How are your programming skills? Which language do you want to learn in? If you know several, switching is trivial down the line, as the API's are similar between languages.

If you don't have skills in any Selenium supported programming language (java, c#, python, ruby, php, etc), then learn one of those before you even touch Selenium. If you have a language in mind, please phrase your question using that in context.

happy hacking,

-Corey

p.s. now go RTFM: http://seleniumhq.org/docs/

rant over.

Python Timer Class - Context Manager for Timing Code Blocks

2012-06-17T10:39:00.000-04:00

Here is a handy Python Timer class. It creates a context manager object, used for timing a block of code.

from timeit import default_timer


class Timer(object):
    def __init__(self, verbose=False):
        self.verbose = verbose
        self.timer = default_timer
        
    def __enter__(self):
        self.start = self.timer()
        return self
        
    def __exit__(self, *args):
        end = self.timer()
        self.elapsed_secs = end - self.start
        self.elapsed = self.elapsed_secs * 1000  # millisecs
        if self.verbose:
            print 'elapsed time: %f ms' % self.elapsed

To use the Timer (context manager object), invoke it using Python's `with` statement. The duration of the context (code inside your `with` block) will be timed. It uses the appropriate timer for your platform, via the `timeit` module.

Timer is used like this:

with Timer() as target:
    # block of code goes here.
    # result (elapsed time) is stored in `target` properties.

Example script:
timing a web request (HTTP GET), using the `requests` module.

#!/usr/bin/env python

import requests
from timer import Timer

url = 'https://github.com/timeline.json'

with Timer() as t:
    r = requests.get(url)
    
print 'fetched %r in %.2f millisecs' % (url, t.elapsed)

Output:

fetched 'https://github.com/timeline.json' in 458.76 millisecs

`timer.py` in GitHub Gist form, with more examples:

My Evolving Droids

2012-06-16T09:25:00.000-04:00

(Droid -> Droid X -> Droid Razr) [stock pics]

In the past few years, mobile devices have turned into amazing little pocket computers. I'm blown away by the hardware (ARM) and software (Android) evolution.

For smartphone wireless service, I was a Verizon customer (USA) for the past decade. I've owned the flagship Droid series devices by Motorola since their first launch (currently running on the 4G LTE network). It started with a clunky original Droid, followed by a Droid X, and then the sleek Droid Razr... every year another generation of better, faster devices.

Device Specs:

Motorola Droid - Nov 2009

OS: Android v2.0
CPU: 600 MHz ARM Cortex-A8 (TI OMAP3430, 65nm)
RAM: 256 MB
Internal Storage: 512 MB
Screen Size: 3.7 inch
Resolution: 480 x 854

Motorola Droid X - July 2010

OS: Android v2.1
CPU: 1 GHz ARM Cortex-A8 (TI OMAP3630, 45nm)
RAM: 512 MB
Internal Storage: 8 GB
Screen Size: 4.3 inch
Resolution: 480 x 854

Motorola Droid Razr - Nov 2011

OS: Android v2.3
CPU: 1.2 GHz dual-core ARM Cortex-A9 (TI OMAP4430, 45nm)
RAM: 1 GB
Internal Storage: 16 GB
Screen Size: 4.3 inch
Resolution: 540 x 960

However, my life with the Moto Droids is coming to an end. I just signed up with a new wireless carrier and pre-ordered a new Sammy GS3!:

(Samsung Galaxy S3) [stock pic]

Samsung Galaxy S3 - June 2012

OS: Android v4.0
CPU: 1.5 GHz dual-core Krait (Qualcomm Snapdragon S4 MSM8960, 28nm)
RAM: 2 GB
Internal Storage: 16 GB
Screen Size: 4.8 inch
Resolution: 720 x 1280

Home Audio Setup

2012-06-14T12:40:00.000-04:00

I work from my apartment and listen to music or talk-radio nearly 24-hours a day (even at soft volume while I sleep). My home audio setup is pretty important to me.

Here is a description of the current rig for home listening:

The Gear:

Media Server (Ubuntu, Logitech Media Server)
Touchscreen UI (Android, Squeezebox Controller)
Wifi Music Player (Squeezebox Touch)
Amplifier (Harman Kardon)
5 Speakers (Polk Audio)

The Content:

Streaming Radio Networks:

Slacker Radio Plus ($3.99/month) - slacker.com
SiriusXM Internet Radio ($14.49/month) - siriusxm.com
Pandora (Free account) - pandora.com
SomaFM (Free) - somafm.com

MP3 Collection:

7010 Files
60 GB
Track List: Corey's MP3s

Tablet interface (Logitech Squeezebox Controller):

Web interface (Logitech Media Server 7.7.2):

Rock on!

History of Python - Development Visualization - Gource

2012-06-04T15:45:00.002-04:00

I made a new visualization. Have a look!

History of Python - Gource - development visualization (august 1990 - june 2012)
[HD video, encoded at 1080p. watch on YouTube in highest resolution possible.]

What is it?

This is a visualization of Python core development. It shows growth of the Python project's source code over time (August 1990 - June 2012). Nearly 22 years! The source code history and relations are displayed by Gource as an animated tree, tracking commits over time. Directories appear as branches with files as leaves. Developers can be seen working on the tree at the times they contributed to the Python project.

Video:
Rendered with Gource v0.37 on Ubuntu 12.04

Music:
Chris Zabriskie - The Life and Death of a Certain K Zabriskie Patriarch

Repository:
cpython 3.3.0 alpha, retrieved from mercurial on June 2 2012

for more visualizations and other videos, check out my YouTube channel.

SST 0.2.1 Release Announcement (selenium-simple-test)

2012-04-23T14:02:00.000-04:00

SST version 0.2.1 has been released.

SST (selenium-simple-test) is a web test framework that uses Python to generate functional browser-based tests.

SST version 0.2.1 is on PyPI: http://pypi.python.org/pypi/sst

install or upgrade with:

pip install -U sst

Changelog: http://testutils.org/sst/changelog.html
SST Docs: http://testutils.org/sst
SST on Launchpad: https://launchpad.net/selenium-simple-test

SST downloads | (Jan 1 2012 - April 23 2012)

1600+ downloads from PyPI since initial release.