You can use (?:[\s]|^)(one|common|word|or|another)(?=[\s]|$) instead.

It will not match one's , someone ,etc...

Check DEMO

If you want to use regex you have to construct the regex string in your code from the lists.

You have to sting all the words together using regex '|' or - and that might not be the most efficient solution depending on the length of the word lists.

But lets start with the base regex:

\bAWORD\b

Will match "AWORD". \b means word boundary, meaning we don't match partial words. In sted of AWORD we can use a list here: (word1|word2|...ect).

This list you can construct in with python, like so:

import re
word_list1 = ['foo', 'bar', 'Python']
word_list2 = ['me', 'you', 'we']

words1 = '|'.join(word_list1)
words2 = '|'.join(word_list2)
regex = r'\b(?:{})\b'
test_str = "foo is a me word"
return (re.search(regex.format(words1), test_str) and
        re.search(regex.format(words2), test_str)) != None

.format just inserts the '|' spectated words into the regex in place of '{}'. I am sure the is a more "pythonic" way of doing this, but this is the regex way. :)

I think the look-aheads are overkill in this case, and you would be better off using word boundaries with the ignorecase option,

\brocket\b

In other words, in python:

>>> x="rocket's"
>>> y="rocket1."
>>> c=re.compile(r"\brocket\b",re.I)  # with the ignorecase option
>>> c.findall(y)
[]
>>> c.findall(x)
['rocket']

Here's one way to implement some equivalent to the "AND"ing of regexp needed for this specific application.

The word at point is first character sorted so that dollars becomes adllors in a temporary buffer. That temporary sorted string is then matched with occurrence of any optional alphabet followed by d, followed by any optional alphabet followed by l, followed by any optional alphabet followed by s, followed by any optional alphabet. If that match is true, the word is highlighted, else a message is displayed.

To do this over the whole buffer, do M-x my/match-word-whole-buffer.

(defun my/match-word ()
  "Matches words containing all chars d, l, s in any order: dollars solid 
Match will fail if a word is missing any of those characters. e.g. dollar"
  (interactive)
  (let ((this-word (thing-at-point 'word)); get the word at point
        (match))
    (with-temp-buffer
      (insert this-word)
      (sort-regexp-fields nil "\\w" "\\&" (point-min) (point-max)) ; sort chars in word
      (beginning-of-buffer)
      ;; Now that the chars are sorted alphabetically, you can search for
      ;; the letters in alphabetical order: d, l, s
      (if (looking-at "\\w*[d]+\\w*[l]+\\w*[s]+\\w*")
          (setq match t)
        (setq match nil)))
    (when match
      (highlight-symbol-at-point))))

(defun my/match-word-whole-buffer ()
  (interactive)
  (beginning-of-buffer)
  (forward-word)
  (while (not (eobp))
    (when (string-match "\\w\\{3,\\}" (thing-at-point 'word))
      (my/match-word))
    (forward-word)))

regex module has named lists (sets actually):

#!/usr/bin/env python
import regex as re # $ pip install regex

p = re.compile(r"\L<words>", words=['fun', 'dum', 'sun', 'gum'])
if p.search("I love to have fun."):
    print('matched')

Here words is just a name, you can use anything you like instead.
.search() methods is used instead of .* before/after the named list.

To emulate named lists using stdlib's re module:

#!/usr/bin/env python
import re

words = ['fun', 'dum', 'sun', 'gum']
longest_first = sorted(words, key=len, reverse=True)
p = re.compile(r'(?:{})'.format('|'.join(map(re.escape, longest_first))))
if p.search("I love to have fun."):
    print('matched')

re.escape() is used to escape regex meta-characters such as .*? inside individual words (to match the words literally).
sorted() emulates regex behavior and it puts the longest words first among the alternatives, compare:

>>> import re
>>> re.findall("(funny|fun)", "it is funny")
['funny']
>>> re.findall("(fun|funny)", "it is funny")
['fun']
>>> import regex
>>> regex.findall(r"\L<words>", "it is funny", words=['fun', 'funny'])
['funny']
>>> regex.findall(r"\L<words>", "it is funny", words=['funny', 'fun'])
['funny']

As a regular expression, you could do this:

Pattern p = Pattern.compile('(?i)(one|two|three)');
Set<String> expected = new Set<String>{'one','two','three'};
Set<String> matches = new Set<String>();
Matcher m = p.matcher(result);
while(m.find()) {
  matches.add(m.group(0).toLowerCase());
}
if(matches == expected) {
  // All matches were found //
}