Esempio n. 1
0
File: tests.py Progetto: slok/dwarf
    def test_click_link(self):

        data = {
            "LANG": "en_US",
            "REMOTE_ADDR": "72.14.207.99",
            "HTTP_USER_AGENT": "Mozilla/5.0 (X11; Linux x86_64; rv:17.0)" + " Gecko/17.0 Firefox/17.0",
        }

        # Prepare the database
        counter = random.randrange(0, 100000)
        url = "http://xlarrakoetxea.org"
        sl = ShortLink(counter=counter, url=url)
        sl.save()

        # Call teh task
        result = tasks.click_link.delay(sl.token, data)
        # Wait (for testing only)
        result.get()

        # Check the stored information
        c = Click.find(sl.token, 1)

        self.assertEquals("en_US", c.language)
        self.assertEquals("linux x86_64", c.os)
        self.assertEquals("firefox", c.browser)
        self.assertEquals("72.14.207.99", c.ip)
        self.assertEquals("US", c.location)
Esempio n. 2
0
File: tests.py Progetto: slok/dwarf
    def test_save_shortLink(self):
        counter = random.randrange(0, 100000)
        url = "xlarrakoetxea.org"
        creation_date = dateutils.unix_now_utc()
        clicks = 20
        title = "This is a title"
        host = url
        disabled = True

        # Save the links
        sl = ShortLink(counter=counter, url=url, creation_date=creation_date,
                        clicks=clicks, title=title, host=host)
        sl.disabled = disabled
        sl.save()

        r = redis.StrictRedis(host=settings.REDIS_HOST,
                             port=settings.REDIS_PORT,
                             db=settings.REDIS_DB)

        # Construct the Keys
        rtk = ShortLink.REDIS_TOKEN_KEY.format(utils.counter_to_token(counter))
        ruk = ShortLink.REDIS_URL_KEY.format(url)

        # Check
        token = utils.counter_to_token(counter)
        self.assertTrue(token in r.smembers(ruk))
        keys = ('url', 'creation_date', 'clicks', 'title', 'host')
        data = [url, creation_date, clicks, title, host]
        aux = r.hmget(rtk, keys)

        data_result = [aux[0], int(aux[1]), int(aux[2]), aux[3], aux[4]]
        self.assertEquals(data, data_result)
Esempio n. 3
0
File: tests.py Progetto: slok/dwarf
    def test_click_findall(self):
        url = "http://xlarrakoetxea.org"
        clicks = set()

        # Save
        sl = ShortLink(url=url)
        sl.save()

        # Clicks
        for i in range(random.randrange(0, 5)):
            c = Click(token=sl.token, os="linux")
            c.save()
            clicks.add(c)

        clicks2 = Click.findall(sl.token)

        self.assertEquals(len(clicks), len(clicks2))

        for i in clicks:
            clicks2_aux = set(clicks2)
            for j in clicks2_aux:
                if i == j:
                    clicks2.remove(j)

        self.assertEquals(0, len(clicks2))
Esempio n. 4
0
File: tests.py Progetto: slok/dwarf
    def test_click_store_autofields(self):

        token = utils.counter_to_token(random.randrange(0, 100000))
        url = "http://xlarrakoetxea.org"
        OS = "linux"
        ip = "111.222.333.444"
        incr_times = 4

        # Store a link
        sl = ShortLink(token=token, url=url)
        sl.save()

        for i in range(incr_times):
            ShortLink.incr_clicks(token)

        c = Click(token=token, os=OS, ip=ip)

        c.save()

        # The save method has set the click_date
        click_date = c.click_date
        self.assertIsNotNone(click_date)

        # Check the stored object
        key = Click.REDIS_CLICK_KEY.format(token, c.click_id)
        r = get_redis_connection()
        values = r.hgetall(key)

        # Check the key is correctly set (this means that the counter has
        # increased correctly)
        correct_key = Click.REDIS_CLICK_KEY.format(token, incr_times + 1)
        self.assertEquals(correct_key, key)

        self.assertEquals(OS, values["os"])
        self.assertEquals(ip, values["ip"])
Esempio n. 5
0
File: tests.py Progetto: slok/dwarf
    def test_delete_link(self):
        counter = random.randrange(0, 100000)
        url = "xlarrakoetxea.org"

        sl = ShortLink(counter=counter, url=url)
        sl.save()

        r = get_redis_connection()

        times = random.randrange(10, 100)

        for i in range(times):
            c = Click(token=sl.token)
            c.save()

        self.assertTrue(r.exists(ShortLink.REDIS_TOKEN_KEY.format(sl.token)))
        self.assertTrue(r.sismember(ShortLink.REDIS_URL_KEY.format(sl.url),
                                    sl.token))
        self.assertEquals(times, len(r.keys(
                                Click.REDIS_CLICK_KEY.format(sl.token, "*"))))

        sl.delete()

        self.assertFalse(r.exists(ShortLink.REDIS_TOKEN_KEY.format(sl.token)))
        self.assertFalse(r.sismember(ShortLink.REDIS_URL_KEY.format(sl.url),
                                     sl.token))
        self.assertEquals(0, len(r.keys(
                                Click.REDIS_CLICK_KEY.format(sl.token, "*"))))
Esempio n. 6
0
File: tests.py Progetto: slok/dwarf
    def test_getall_shortlink(self):
        times = random.randrange(1, 20)

        for i in range(times):
            url = "xlarrakoetxea{0}.org".format(i)
            sl = ShortLink(url=url)
            sl.save()

        sls = ShortLink.findall()
        self.assertEquals(times, len(sls))
Esempio n. 7
0
File: tests.py Progetto: slok/dwarf
    def test_get_shortLinks_by_url(self):
        times = 10
        counters = [random.randrange(0, 100000) for i in range(times)]
        url = "xlarrakoetxea.org"

        for i in counters:
            sl = ShortLink(counter=i, url=url)
            sl.save()

        sls = ShortLink.find(url=sl.url)

        self.assertEquals(len(counters), len(sls))
Esempio n. 8
0
File: tests.py Progetto: slok/dwarf
    def test_get_shortLink_by_token(self):
        counter = random.randrange(0, 100000)
        url = "xlarrakoetxea.org"
        title = "My webpage"
        host = "xlarrakoetxea.org"

        sl = ShortLink(token=utils.counter_to_token(counter), url=url, title=title, host=host)
        sl.save()

        sl2 = ShortLink.find(token=sl.token)

        self.assertEquals(sl, sl2)
Esempio n. 9
0
File: tests.py Progetto: slok/dwarf
    def test_get_shortLink_by_counter(self):
        counter = random.randrange(0, 100000)
        url = "xlarrakoetxea.org"
        title = "My webpage"
        host = "xlarrakoetxea.org"

        sl = ShortLink(counter=counter, url=url, title=title, host=host)
        sl.save()

        sl2 = ShortLink.find(counter=counter)

        self.assertEquals(sl, sl2)
Esempio n. 10
0
File: tests.py Progetto: slok/dwarf
    def test_disable_link(self):
        clicks = random.randrange(0, 100000)
        counter = random.randrange(0, 100000)
        url = "xlarrakoetxea.org"

        sl = ShortLink(counter=counter, url=url, clicks=clicks)
        sl.save()

        sl.disable()

        #Find
        sl2 = ShortLink.find(token=sl.token)
        self.assertTrue(sl2.disabled)
Esempio n. 11
0
File: tasks.py Progetto: slok/dwarf
def create_token(url, user_id=None, notification=True):
    # Get the next counter to create the token
    counter = ShortLink.incr_counter()

    # Sanitize the url
    url = sanitize_url(url)

    # Get the title
    # Fix this!! test if the url exists or not!!
    try:
        title = extract_url_title(url)
    except:
        title = "No title"

    # Get the host
    host = extract_url_host(url)

    # Create the instance with the data
    sl = ShortLink()
    sl.counter = counter
    sl.url = url
    sl.title = title
    sl.host = host

    # Save
    sl.save()

    # If is a user link save it also
    if user_id:
        user_link = UserLink()
        user_link.user = User.objects.get(id=user_id)
        user_link.token = sl.token
        user_link.save()

        # Only need notification if we have a user
        if notification:
            # Send notifications
            notif = ShortLinkNotification(sl, user_id=user_id)
            #notif.send_push()  # Push realtime notification
            notif.save()  # save the notification for the dashboard

    # Fill the metrics
    SharedLinkMetrics().increment()

    logger.debug("{0} shorted url '{1}' to token '{2}'".format(user_id,
                                                               url,
                                                               sl.token))

    # Return the new token
    return sl.token
Esempio n. 12
0
File: tests.py Progetto: slok/dwarf
    def test_decr_clicks(self):
        clicks = random.randrange(0, 100000)
        counter = random.randrange(0, 100000)
        url = "xlarrakoetxea.org"

        sl = ShortLink(counter=counter, url=url, clicks=clicks)
        sl.save()

        #decrement
        result = ShortLink.decr_clicks(sl.token)

        #decrement manually the old one
        sl.clicks = sl.clicks - 1

        #Find
        sls = ShortLink.find(token=sl.token)

        self.assertEquals(sl.clicks, sls.clicks)
        self.assertEquals(result, sls.clicks)
Esempio n. 13
0
File: tests.py Progetto: slok/dwarf
    def test_click_find(self):
        token = utils.counter_to_token(random.randrange(0, 100000))
        OS = "linux"
        ip = "111.222.333.444"
        browser = "firefox"
        click_date = dateutils.unix_now_utc()
        language = "EN_us"
        location = "US"
        url = "http://xlarrakoetxea.org"

        sl = ShortLink(token=token, url=url)
        sl.save()

        c = Click(
            token=token, os=OS, ip=ip, browser=browser, click_date=click_date, language=language, location=location
        )
        c.save()

        c2 = Click.find(token, c.click_id)
        self.assertEquals(c, c2)
Esempio n. 14
0
File: tests.py Progetto: slok/dwarf
    def test_save_shortLink_autofield(self):
        times = random.randrange(1, 100)
        url = "xlarrakoetxea.org"
        title = "My webpage"
        host = "xlarrakoetxea.org"

        # Set the shor link counter
        for i in range(times):
            ShortLink.incr_counter()

        # Save
        sl = ShortLink()
        sl.url = url
        sl.title = title
        sl.host = host
        sl.save()

        # Check the correct counter
        sl2 = ShortLink.find(counter=times + 1)
        self.assertEquals(sl, sl2)